Another day, and here I go again, talking about all these things our software relies on. This time, I want us to try and change how we think about them.

You know how we developers often just grab ready-made pieces of code (we call them dependencies) and plug them into our projects to make things faster? It feels like we're always updating these pieces, fixing them, checking them, and dealing with even more little pieces that they rely on. It's like being on a never-ending running machine. Who hasn't had to wait for their computer to update some tool just to fix a problem they didn't even have?

This problem is everywhere in software where we can easily add these ready-made pieces. It's especially bad in places like JavaScript and Rust. For example, a brand new, simple project in Rust can end up pulling in dozens or even hundreds of these extra pieces of code.

Think about something really basic, like figuring out how big your computer screen (terminal) is. The way computers do this hasn't really changed in like 50 years! Yet, a ready-made piece of code for this in Rust pulls in several other pieces, depending on your computer. This means your computer ends up having to process thousands of lines of extra code just to find out if your screen is, say, 80 by 25 or 120 by 40. This simple piece of code has been updated dozens of times!

So why does that screen-size code need so many updates? Because it's built on top of other collections of code that are constantly changing. So, it has to update to avoid making things even more complicated and taking even longer to build your software.

But the experts will tell you this is the only way to do things. They'll say you shouldn't just copy and paste code or write some of the basic stuff yourself (unsafe code). They act like you're not good enough and that the experts should handle it. Otherwise, you'll get criticized. There are even companies making money by helping you manage all these extra pieces of code! We're told we need these dependencies and have to keep them updated for security, but often, these dependencies are where security problems actually come from.

The goal of writing code should be to make it so it doesn't need constant updates. It should eventually become stable. But in the Rust world, if your code works perfectly but hasn't had many updates recently, it can actually get a bad rating!

But there's an easier way: just write the code yourself. Yes, it takes more time at the beginning, but once it's done, it's done. No new extra pieces, no waiting for other people to fix problems. If something is wrong for you, you fix it yourself. Code that works doesn't always need to be constantly updated. Your code has a rare problem? Who cares if it's rare! This is the change in attitude we need in the Rust world: celebrating having fewer extra pieces of code, not more.

We've reached a point where just grabbing ready-made code isn't just the normal thing to do, it's seen as a good thing! People say, Look how organized and put-together my code is! But maybe it just means they don't want to type more than a few lines of code themselves.

Now, some will argue that writing everything yourself takes too much time. But it's 2025, and it's often faster for AI tools to quickly write a simple version of these common things without any extra dependencies than it is to go through the hassle of adding and managing those dependencies. And it makes sense because for many of these small, basic tasks, the work needed to keep your own code running is much less than constantly updating and dealing with problems in all those extra pieces. The code is often just a few lines, and you also don't have to wait for your computer to process thousands of lines of other people's code just for one little function.

To be continued...