Misc

You can’t be hit by supply chain attacks if you don’t have a supply chain.

C/C++’s terrible dependency management might actually be a feature. When adding a library requires real consideration instead of one line in a config file, you end up with manageable codebases. Modern package managers make accumulating 100+ unknown dependencies trivially easy.

Want a simple web server? You get everything but the kitchen sink.

Modern libraries are coarse-grained monstrosities. Ask for HTTP handling, receive JSON parsers, PAM authentication, SSL, QUIC, websockets, async frameworks, and database connectors. Sometimes the subset you need is 5% of what you’re forced to import.

Microservices reality: 6 services, 20-minute startup, 6 terminals.

One developer’s story: just to test locally, launch 6 microservices in a specific order, keep each in separate terminals for debugging, 20-minute startup time. The CEO doesn’t like work that doesn’t yield visible features. No time to automate what happens a few times per week.

Changing a button color should not take half a day.

Bloat isn’t just size - it’s layers upon layers of indirection. Find button code, change color, nothing happens. Dig through module settings, global themes, 17 different config files. One predecessor couldn’t figure it out either, so he just changes the color to brown every second in a timer loop.

Who thought writing a build system in Python was a good idea?

Looking at you, Gentoo’s Portage. Every emerge operation becomes a Python dependency nightmare. One broken setuptools update and your entire package manager is toast. Build systems should be simple, fast, and reliable - not dependent on a language ecosystem known for breaking backwards compatibility.

Most “DevOps” tools are overcomplicated solutions to problems that a shell script could solve.

Spent years watching teams adopt massive orchestration platforms to deploy simple web apps. A cron job and rsync would have done the same thing with 99% less complexity.

Kubernetes is fine if you actually need it. Most people don’t.

If you’re not running hundreds of services with complex networking requirements, you’re just creating operational overhead. Your startup with 3 microservices doesn’t need K8s.

The best debugger is still printf().

Fancy debuggers break when you need them most. Printf works everywhere, in every language, even when everything else is on fire. Simple tools are reliable tools.

Docker broke more things than it fixed, but at least dependency hell is someone else’s problem now.

Remember when applications just ran on the system? Now we package entire Linux distros to run a single binary. But hey, at least “works on my machine” isn’t an excuse anymore.

If your build process requires more than 3 commands, you’re doing something wrong.

configure, make, make install. That’s it. If your build system needs a 50-line README just to compile “hello world”, you’ve overcomplicated things.

Static linking is underrated. Dynamic linking was a mistake.

Library compatibility hell, missing .so files, version conflicts. Static binaries just work. One file, no dependencies, deploy anywhere. Worth the extra disk space.

Most performance problems are caused by doing unnecessary work, not by the language being “slow”.

Before you rewrite everything in Rust, maybe stop making 47 database queries to render one page. Profile first, optimize algorithms, then worry about language performance.

Configuration management tools are great until they break and you have to debug YAML.

Ansible playbooks turn into unmaintainable spaghetti. Terraform state gets corrupted. Sometimes a shell script that you can actually read and understand is better.

The cloud is just someone else’s computer, and they charge you extra for the privilege.

AWS bills that cost more than a dedicated server. Vendor lock-in disguised as convenience. Sure, it scales, but most applications never need that scale.

.NET, WSL and PowerShell are open source now. What timeline are we living in?

Microsoft went from “Linux is a cancer” to shipping a Linux kernel with Windows. .NET runs on Linux better than some native tools. PowerShell is actually decent for automation now. Either hell froze over or someone at Microsoft finally understood that developers don’t want vendor lock-in.