Ever been in a Frontend interview where the interviewer asks you to explain all the Promise methods, in particular, 

? Sometimes they just ask for the definition. Sometimes, a code example of each one.

Let me give you some examples of what I typically do when I'm asked about them.

Nailing this one is a good sign, it's usually the first they ask. The definition itself is quite simple, but the implementation can get tricky.

Before diving into code, let's break it down:

 that only resolves when all of them are resolved

If any of the promises are rejected, the whole thing is rejected immediately as well (aka fail-fast)

Keeps the original order of results, regardless of which Promise finished first

 assignment. This matters because depending on whether the last promise is faster than the other ones, it will be return first, for example:


 , the main differences are what is returned and the fact that it doesn't stop at the first rejection.It always waits for every promise to settle and returns each result as either 

. No matter what happens, it collects all results and resolves at the end. It never rejects.

 is definitely the simplest one to understand, no tricks, no deep logic. You just need to return the first finished promise, whether it resolves or rejects.

That's it. Nothing else. It's kind of a race, whichever Promise finishes first 

, and that's the result you get. The rest are ignored. Simple enough, right?

 only fails if everyone fails. Otherwise, it keeps going until it finds the first resolved one.

So, finally, our output should be something like this:

 takes whoever is fastest, whether it resolves or rejects. 

 takes the first win and only gives up when there's nothing left to win.

Implementing Promise.all, allSettled, race and any from scratch

Last week, I was cleaning up my old notes and came across something interesting. A page with some drawings, arrows, and train stations trying to explain the JavaScript Event Loop to a teammate. He lived in a city famous for its train network, so I figured it was a good starting point. It worked for him. Not so much for me at the time haha

But going through those notes again, I thought it was worth sharing. The goal here is the same as it was back then: explain what the Event Loop and single-thread mean in a really simple way without turning it into a lecture. Just a real-world example, as close to everyday life as possible.

Before we start, let's get on the same page

Think of a subway with a single conductor. One conductor, one train, one thing at a time. No multitasking, no skipping steps. That's JavaScript.

 = a Macrotask (setTimeout, click event handler, fetch API response, UI rendering...)

 at each stop = Microtasks (Promises, async/await, queueMicrotask, MutationObserver, ...)

The rule is simple: the train doesn't leave until every single item on that checklist is done. Even the ones added while the conductor is already checking.

 The moment you arrive, the checklist shows up:

)? Added while the conductor was already working through the list. Doesn't matter. Can't leave until everything is cleared, old and new ones.

Then the whole thing repeats at Station B. And C. And every other station, for as long as the app is running.

If you keep adding new items to the checklist every time you finish one, the train never departs. That's exactly what 

 does. The queue never empties and the browser just freezes. Nothing moves, no UI updates, nothing.

So, using code as example, here's what that "infinite checklist" looks like:

. Instead of extending the current checklist forever, it schedules a brand new station stop. Safe, simple, done.

That's really it. One conductor, one checklist, one station at a time. Running forever in a loop.

There's more to the Event Loop than this, edge cases, exceptions, browser quirks. But if you leave with this picture in your head, you've got the foundation. The rest is just extra stops on the same line.

You can go deeper by checking out these links below:

JavaScript Visualized - Event Loop, Web APIs, (Micro)task Queue

 — honestly the best visual explanation I've seen

Trying to explain the Event Loop/Single-thread with a train

Recently, the company I've been working for faced a malware attack through a GitHub user. This GitHub account had its credentials stolen somehow, which ended up making the hacker's life easier to implant a malicious obfuscated JavaScript payload into 

 and spread it across a few other projects. It wasn't clear how the code worked. But you can check out more info here: 

PolinRider: DPRK Threat Actor Implants Malware in Hundreds of GitHub Repos

 until we figured out how it worked and how to prevent it from spreading further. In the end, we ran a few code checkers and rotated sensitive tokens.

The key point is: this happened at dawn, between 3–5 am. The affected user had high admin powers across plenty of projects, so the hacker could just force push without needing any extra effort. How they found out exactly who had so much power is a good question. A very very good bet.

That morning was tense, full of stress and investigation. Things could have been much worse if someone hadn't noticed it early in the morning.

Lucky for me, that day I started working a bit later than usual. When I sat down to read all the threads, I saw all the chaos that had been unfolding in the dev channel. At least the day ended up fine, no big problems overall, nobody else affected, all good. Aside from the first dev impacted, he had a few nightmares for sure.

All of this triggered several red flags, especially around permissions and the need for stricter rules in branch controls. Fair enough, right? Since I also had some "super powers," I had them all taken from me. I believe it's better this way. Better to prevent than to deal with it again. As Peter Parker's Uncle Ben says: 

"With great power comes great responsibility". 

Mainly in an environment where a lot of developers have admin roles and work on multiple projects at once. We need to restrict things carefully and control project security more and more every day.

Our incident was small scale. But it made me pay more attention to what's been happening out there. I've seen many leaks, attacks, and large companies being hacked recently. 

Lovable (Apr/2026), Vercel (Apr/2026), Salesforce (Aug/2025), Red Hat GitLab (Oct/2025)

 and these are just a few. I have the impression that things weren't like this a while ago. It seems recent. Anyway, as these situations are becoming more frequent, we can say they are no longer exceptions. What's happening that we haven't caught yet?  Programming has been changing continuously, that's for sure. But what else?

To say the reason is the rise of AI is, in my view, an overly simplistic take that minimizes our own responsibilities. However, there is a missing piece in this puzzle, something that is beyond our reach. Perhaps we'll discover it in the coming chapters written in 0s and 1s. I hope so.

In case you've also been impacted by something similar (hopefully not), here's what we did to make sure everyone was safe:

If you have Claude Code, you can use a prompt like: 

"Please check my whole system to see if I'm still affected by the following malware"

, starting with the drive that contains your profile. This should be a system-wide check, but you can start with your main local folder.

, and anything else that could give sensitive access to attackers

Delete the affected branch or remove the malicious code

Vercel confirms breach as hackers claim to be selling stolen data

Lovable denies data leak, cites 'intentional behavior'

Two Days, Two Hacks: The Lovable Disclosure and the Pattern Nobody Wants to Talk About

Hacks, thefts, and disruption: The worst data breaches of 2025

https://medium.com/@0xOZ/how-to-get-scammed-by-dprk-hackers-b2f7588aea76

https://github.com/OpenSourceMalware/PolinRider

Hacker attacks and data breaches are no longer exceptions. Until when?

Recently, I started helping a friend with an e-commerce site, which is not really my area. Especially when it involves platforms like "NuvemShop", "uCommerce", and all these kinds of stuff.

E-commerce is definitely not my thing. I have nothing against it. The problem is that they require more work to do simple things that should just be simple. Kind of a nightmare sometimes.

I know there are a lot of new tools and platforms like 

 that can make your life easier. However, these platforms aren't easy for non-tech people, and for Brazilians, the pricing doesn't help either, since most of them charge in dollars. Even though they have great documentation, drag & drop UIs, and all these cool things, non-tech people still don't get it. That's why they ask friends to help lol

Given that, my task was to develop a few pages using their NuvemShop subscription. Terrible experience. There are a lot of limitations in the NuvemShop page builder, which almost made me cry. So I tried to look at it as an opportunity to learn something new. Try to understand how developers have been doing this kind of work nowadays.

And to my sadness, there is no fancy AI-powered, cool, or happy new way to make it work.

 
Then, I saw a message in the panel saying: 

"You can edit the HTML, CSS and Javascript directly from an FTP client using these access credentials."

FTP? Directly? So, you mean... FileZilla?

The ancient FTP client that developers have been using since before some of us were born. The one with the UI that looks like Windows XP had a rough night. Four cluttered panels, a raw protocol log screaming gibberish at you in real time, and the quiet dread of not knowing if your file actually uploaded or just pretended to.

Working with NuvemShop and FileZilla together in 2026 is a special kind of punishment. You save a file, drag it across panels like it's 2004, wait for the transfer bar to crawl across the screen, only to refresh the page and realize you uploaded it to the wrong folder. So you do it again. And again. And again. And again... No hot reload. No git push. No CI/CD pipeline saving your soul. Just you, a blinking cursor, and FileZilla.

And the worst part? There's no way out when the hosting is old-school shared hosting. You're stuck with it. FileZilla and you, together, suffering, until the deployment is done.

So yeah, the only learning here was that, thankfully, the development world is getting better and better each year. If you're younger and started working with tech nowadays, you're living in a great era. For us, programming dinosaurs, let's all give a hug and celebrate that these times passed fast!!!!! 

It's 2026, FileZilla is still alive, and so am I. Barely.

I think this is the ninth time I'm creating a new website, and each time it feels simpler. It's similar to a developer's life, right? I mean, sometimes we need to rebuild everything or even start from scratch to try out a new perspective.

I'm a Software Engineer with 8+ years focused on frontend, building products that have reached over 65 million users. My core stack is React, Next.js, and TypeScript, but what I care about most is shipping things that actually work well at scale, both technically and for the people using them.

Over the years I've moved between hands-on engineering and leadership: leading cross-functional teams of up to 16 people across frontend, backend, QA, and mobile at companies like 

, and more recently focusing back on building, from platform work at 

 to travel products with complex UX challenges like drag-and-drop, payments, and SSR optimization.

I'm Fernando, nice to meet you

A little bit about me,

Recently written.

Implementing Promise.all, allSettled, race and any from scratch

Trying to explain the Event Loop/Single-thread with a train

Hacker attacks and data breaches are no longer exceptions. Until when?

It's 2026, FileZilla is still alive, and so am I. Barely.