Trigger Warning - Don't date JavaScript developers.

They Promise to Callback but they won't. You'll Await in vain. They don't know how to Express themselves and React to such situations.
You might not be happy to hear this, but I'm trying to save you from a Garbage situation

Just got a new job at an old school hardware company. The codebase is giving me heart attack. They don't care about dev experience or code navigation at all. Every attempts to modernize the codebase is so half assed. All patches are so bloated that make the codebase even worse.

Frontend is migrated from prototype-oop-jquery cluster fuck to AngularJS, then finally angular. Holy moly, all business logics are baked into UI "classes" using prototype chain. When they migrated to AngularJS, someone simply added a wrapper to that jQuery cluster fuck class and overwrote all the prototype with a 10k +lines file. Since all the methods are hidden in either prototype, JS object, or callback function, it's impossible to trace the data pipeline using IDE when "go to definition" on update() method gives you all the update methods/string in all objects/classes. And they don't care about immutability. References are taken out, renamed, and mutated everywhere. Finding the source of a bug is fucking guessing game.

I don't know what trick they use that makes cLion static analyzer fail.

And there is no unit test or spec doc.

Fuck me dead

I feel very anxious when developers interviewing me asks
1. is nodejs single threaded or multithreaded ?
2. How does node handle requests
3. How do u manage concurrency
4. What is event emitter and callback.

Dude i have given you my resume, without knowing these things i could never do that ?

I feel the discussion must be based on concepts and general problem solving rather than focusing on one technology. Tech can always be learnt.

[CMS Of Doom™]
Ah, yes, their built-in bullshit newsletter module just sent the n-th user n emails. Wonderful considering n=368.

The culprit? Better don't ask...
OK, anyway: So the mailer is running as a CRONjob, but nah, not as a console script call but by a public HTTP GET URL call, fucking obviously (it's the CMS Of Doom for a reason).
So these fucking imbeciles "implemented" an ob_start() callback where HTML links are - for whatever fucking reason - modified by some regex (obviously everybody knows parsing HTML by Regex is trivial). In this case the link was somehow modified to recall the mailer Cronjob...
This must have upset the pngoing mailing process thus spamming mails. Whyyyy

And I've thought I've seen it all after 6 months in this legacy hell...
This is why you don't run a company consisting of only beginners in PHP (in cluding their "CEO")!

I had been banging my head on an issue for 2 days. The solution?

Replaced
“window.addEventListener(“message”, callback)”

with
“window.onmessage = callback”

What. The. Actual. Fuck??!!

Aren’t they supposed to be the same thing?? It’s written on MDN’s article that the latter is an alternative way of doing the former.

What the fuck then? I am actually really pissed right now. Ragefully pissed.

!rant

I've been working with Golang for a while now and I've come to love the generics they introduced. Making stuff type-safe is a bit of a hassle, but it pays off greatly.

One thing I had yet to consider though, is that functions are also a type, so that those could be made generic too.

func DoThing[F func(string) | func(int)](callback F) {...}

Now you can deliver both function types and I can differentiate them using a type switch.

Weird that sometimes my brain doesn't make that connection immediately...

Can we take a moment to recognize how absolutely retarded JS' event system is?
Events aren't objects. No, they're managed by an object, and identified by a string.
To subscribe to an event, you call object.addEventListener(name, callback). Because for some reason we can't just have an event object. Events MUST have an owner.
But to unsubscribe you don't call the function addEventListener returned, you don't use the token it returned either. No, you pass the same function to removeEventListener.
Because we don't use serializable tokens like in PP, and we don't return functions like in FP, no, we use functions as tokens, realising idiomatic DFP.

WHO THE FUCK THINKS
THIS SHIT
TS:
```
const a = function(callback: (err:any,data:string) => void):void{
callback(null,'balls');
}

a(function(err:any,data:string){
console.log(err,data)
})
```

IS BETTER THAN THIS
ES6:
```
const a = function(callback){
callback(null,'balls');
}

a(function(err,data){
console.log(err,data)
})
```

kys

Currently fixing concurrency issues with a callback which is called so frequently it probably has multiple instances running and which can't ever be paused. Also, it isn't allowed to allocate or free memory. Riddles like this are the reason I got into computer science.

Neat trick that I discovered today:
Because React.useCallback is a thing, you never need a custom react hook to take a dependency array. You can always express your dependencies by wrapping the callback in useCallback and having useCustom pass the callback itself as its own dependency.

Rant/question:
httpDoSmth1().subscribe(x =>
...then(y =>
httpDoSmth2(x).subscribe(z =>
//do smth with z
return z
)
)
)
Isn't this (not my code) callback hell all over again? The 2. http call expects results from the 1. http call. I feel like this could be solved cleaner using async await/switchMap/etc. ... but not like this.

Typescript is my new favorite and my grudge is the stupid scoping of type assertions. I have an async function that checks whether a variable is set and awaits a change event if it's undefined. This function is working javascript but invalid according to typescript, because it relies on the exact type changing while the function is running. I had to convert it to a mess of promises to bypass this because (and this is the best) the callback-based syntax of identical meaning will reset all type assertions, even locals that are never written after the callback's creation.

[typescript] Should I use a promise to represent an event that can occur at most once, may never occur but can never fail? If not, what else should I use? Callbacks?

how do callback functions work in js?

Why is laravel so poorly documented? Take \Illuminate\Mail\Mailer::send() as example. The third parameter is a callback. Nothing more. No info in the docblock what that callback does, when it is called or what the signature looks like. You have to go into the code and hope to find it out without climbing through a dozen classes.

If they are so sparse with the information in the docblock, they can leave it away completely.