The Reverse Engineering Brainfuck

Sorry for this almost provocative title.

Anyone who works in tech and regularly reads about it has probably heard about a new tool called REA - Reverse Engineer Anything. The name pretty much explains what it does.

I found it interesting. Especially the idea of figuring out how certain features work without spending years digging through binaries. But then I overheard a conversation at university about it. Apparently, we don't need to develop software anymore. Why would anyone still build apps if we can just reverse engineer them? You don't need Spotify anymore if you can just build it yourself… Wait, what?

I get where the idea comes from. If I can reproduce an application, why would I still pay for the original? And if someone publishes the code as open source, everyone could theoretically benefit from it.

But somehow, we're skipping a pretty big part of what software development actually involves.

Reverse Engineering: what's that?

For everyone who already knows what reverse engineering means, feel free to skip this chapter.

Reverse engineering, in this case, means taking software apart to figure out how it works or how it was built, without having access to the original source code or any internal specifications .

Think of an app like Spotify. Spotify is closed source, meaning its source code isn't publicly available. But let's say you want to know exactly how Spotify recommends songs in your Discover Weekly. You start taking the app apart until you eventually find something that might explain part of how it works. Maybe you can see how the Spotify app sends requests to Spotify's servers, how the results are displayed, or any other logic.

What you still don't have are the algorithms running on Spotify's servers, all the data about people's listening habits or the infrastructure behind it. Just because you know which request the app sends doesn't mean you know what happens on the other side.

I would distinguish between three things: Reproducing a feature so that it behaves similarly. Reproducing an app with enough functionality to offer a similar experience. And, reproducing the actual product, meaning something people choose to use, trust, and keep using after the first time.

Of course, all of this can work. It really depends on the application. A small desktop app that converts some files is something completely different from a platform used by millions of people at the same time.

You built a clone. Ok?

Let's assume you managed to reverse engineer an entire application. Now you have a working clone. What happens next? Someone still has to fix the bugs, take care of security, and make sure the app works when something changes in the operating system. And at some point someone has to decide which feature comes next. And why should anyone use your clone?

I can recreate a recipe from a Michelin-starred restaurant. That doesn't make me a Michelin-starred restaurant.

The point is that copying an implementation doesn't automatically reproduce everything around it.

Let's say you successfully rebuilt Photoshop. All the buttons are there, the most important features work, and even the interface looks similar. Congratulations. But now someone opens a PSD file with 150 layers, some Smart Objects, and several gigabytes of images. Does it still work? What happens when someone saves a file and comes back the next day, only to find that half of their work is gone?

It's not that these problems can't be solved. They can, of course. But then, we're right back where we started. We're developing software.

And that's what I don't understand about this whole discussion. As if writing the original code was the only problem when developing an application.

In fact it's often the other way around. Building the first prototype is the easiest part. The real problems come afterward. When people start doing things with your software that you never even thought about.

Nobody is stopping you from building software

I keep noticing how much of a bubble developers actually live in. Thinking that nobody needs apps anymore because everyone can just rebuild the big ones. Why pay for Photoshop when you can simply build it yourself?

But most people don't want to dig through binaries, configure some agents (half of them probably don't even know what agents are), deploy servers or maintain their own software.

They just want an app that works.

And I think we sometimes forget how little most people care about how software actually works. They care about the result. Someone who wants to edit their vacation photos doesn't want to develop photo editing software. They want to edit their vacation photos.

Sure, AI is making it easier to build small tools for yourself. And that's good. If I have a problem that previously required me to search for an app, I can now potentially build something myself within a few minutes. But there's a pretty big difference between a small tool I build for myself and an application I make available to thousands of people.

Now, you could argue that not everyone needs to build their own version of Photoshop. It's enough if one person does it and then publishes the code on GitHub. Everyone else can just download the application for free. Problem solved, right?

And yes, that's actually an argument I can understand. Open source has been around for decades and I think it's booming and slopping at the same time. We already have free alternatives to Photoshop, like GIMP and Krita. And if tools like REA help developers build these applications faster, that's a good thing.

But why isn't everyone already using GIMP or Krita?

Because being free doesn't automatically mean an application is just as good for your needs. Some people are used to certain workflows, others need specific features or compatibility with certain files and plugins. And some simply don't want to spend time learning how to use another application.

I know, a new open-source clone could eventually solve all of these problems. Maybe someone actually builds a free alternative that's even better than Photoshop. And if that happens, companies like Adobe might have a real problem. Why would people keep paying for something if there's a free alternative that does everything they need?

We've already seen with projects like Blender or Linux that open-source communities can build and maintain software over many years. So I don't think maintenance is really a problem here.

But that's also what I don't understand about the argument. People are still developing software. They're building features, fixing bugs, and trying to make the application better. It just happens to be open source.

And then there's the legal side. Being able to reverse engineer an application doesn't automatically mean you're allowed to copy and publish everything you find.

So yes, maybe we'll see more free alternatives to commercial applications. But someone still has to develop them, whether they're reverse engineering an existing product or building something from scratch.

Some software is replaceable

Some software is probably easier to replace than others. Take simple converters or apps that charge subscriptions for the most basic features. I don't really enjoy paying €9 a month just to convert some files either. Especially when I could probably build the same functionality myself with a few lines of code.

And if tools like REA make it easier to build alternatives, I think that's pretty good. Maybe I don't need the entire application anymore. Maybe I just need that one feature I was paying for. But this doesn't work for every kind of software.

Take accounting software, for example. I could probably build some of its features myself. Creating invoices, categorizing expenses, generating reports. (Most of the time) None of that is exactly rocket science.

But would I really want to rely on something I built myself to handle my accounting? What happens when tax regulations change, something breaks, or I suddenly realize that my calculations were wrong?

Maybe I'd be fine with that. Because I use it personally. But many people and companies would rather pay someone else to take care of it. And I think that's something we're mostly overlooking.

The code isn't the whole product

I think we sometimes confuse the code of an application with the actual product. Don't get me wrong. Of course code matters. Without code, the application wouldn't work in the first place. But the code alone doesn't explain why people use a particular piece of software.

Let's take Spotify again. Even if you managed to rebuild the entire interface, implement music playback and maybe even develop your own recommendation algorithm, you still wouldn't have Spotify.

Where does the music come from? Who handles the licenses? How do you get people onto your platform? And why should anyone give up their playlists, saved songs, and listening history just to switch to your application?

Or take WhatsApp. Building a chat application is technically possible today (look at Signal or the thousands of other alternatives). But what's the point of having the best chat app in the world if none of your friends use it?

These are all things you can't simply extract from some binary.

And even with applications where the code actually makes up a large part of their value, there's still one question: Do you really understand why something was implemented the way it was?

Maybe you discover that an application uses a weird and complicated approach for a certain feature. You can see which functions are called, what data gets passed around, and how the application behaves under certain conditions. But that doesn't tell you why someone decided to implement it that way.

Maybe there was some edge case five years ago. Maybe a certain piece of hardware caused problems. Or maybe the simpler solution worked perfectly fine until someone tried using it with a file that was several gigabytes in size.

You can reproduce the behavior without knowing any of that, especially with AI. But maintaining it is a different topic.

So, what's the point?

I'm not trying to make REA look bad. The opposite, actually. I think it's interesting that tools like this make reverse engineering more accessible. Especially when you want to understand how certain features work or investigate software that doesn't have any decent documentation.

What I don't understand is why every new tool immediately has to replace something. We've already had enough discussions about AI replacing developers, designers, and entire companies (or even humans). And now apparently we don't need to develop applications anymore either.

I mean, if someone manages to build a free Photoshop alternative that's just as good as the original, OK, give it to me. But someone still had to build it…

But well. Apparently, something new has to go viral every month.