Software that sucks

Last updated: When I remembered to

Electron

Every Electron app is a Chrome browser pretending to be a program. Slack uses 2GB RAM to display text. TEXT. IRC used 2MB and did the same thing better in 1988.

Same as VS Code. It’s a text editor that needs 300MB to open a file. Vim uses 8MB. Emacs uses 30MB and Emacs is already bloated.

Discord, Teams, Spotify desktop - all browsers in disguise. My entire operating system used to fit in the RAM these “apps” waste.

systemd

Lennart Poettering’s monument to scope creep. Used to be init started processes. Now it’s init, cron, syslog, network manager, boot loader, DNS resolver, and apparently my login manager too.

Binary logs. BINARY. LOGS. Can’t grep a binary. Can’t tail a binary. Need special tools to read what should be text.

PID 1 should do one thing: start processes and reap zombies. Not run a web server. Yes, systemd has a web server.

MongoDB

“Web scale” database that loses data by default. Eventual consistency means never having to say you’re certain.

Kids use it because they’re scared of SQL. Thirty years of relational theory thrown away because writing SELECT is hard.

Lost data? Check the README, it’s a feature. ACID compliance? That’s optional. Transactions? Added in version 4 after a decade of pretending they weren’t necessary.

PostgreSQL does everything MongoDB does, plus it keeps your data.

Docker

A 500MB solution to “works on my machine.” We solved this in the 90s with static linking.

Containers are just processes with namespace isolation. I can do that in 50 lines of C. Docker needs millions of lines and a daemon running as root.

Dockerfiles are shell scripts with more steps and worse syntax. Every RUN creates a layer. Every layer wastes disk space. A “small” container is 100MB. My entire Linux system is 50MB.

npm/node_modules

The dependency manager that downloads the internet. One project, 50,000 files in node_modules. Left-pad was 11 lines and broke half the web when it disappeared.

Every package depends on 47 other packages. Those depend on 200 more. It’s turtles all the way down and the turtles are all broken.

Package.json, package-lock.json, yarn.lock, .npmrc - four files to track what code to download. Make needs one.

Kubernetes

YAML-based distributed systems programming. Because distributed systems weren’t hard enough without adding YAML.

Minimum viable k8s cluster needs 4GB RAM to run hello world. I ran a university’s entire email system on a machine with 4GB RAM.

“Cloud native” means your laptop isn’t powerful enough to run your blog locally.

CMake

Makefile generator that needs its own manual, book series, and support group. The cure is worse than the disease.

Generates Makefiles that no human can read. Debugger? Hope you like print statements. Error messages? “CMake Error at CMakeLists.txt:42”. Thanks, helpful.

Autotools was already bad. CMake looked at autotools and said “hold my beer.”

JIRA

Issue tracking that requires a training course. Every ticket needs 47 required fields. Loading one page makes 200 HTTP requests.

Designed by people who hate both developers and managers. Successfully makes everyone miserable.

We used text files and email. Worked fine. Now I need to update story points in a modal dialog that won’t close.

Zoom

Video conferencing that needs a GPU to blur your background. Skype did video calls in 2003 on a Pentium 4.

Every update changes the UI. Settings move randomly. Features appear and disappear like quantum particles.

Installs an always-running daemon. For video calls. That I make twice a week.

Snap/Flatpak/AppImage

Three different ways to solve the same fake problem. “Dependency hell” was solved by static linking in 1975.

Snap runs a daemon. As root. To install packages. That are just compressed filesystems with binaries inside.

Every app bundles its own libraries. Twenty copies of libssl on disk. Security update? Update twenty packages. Disk space? What’s that?

GitLab

Git hosting that needs 8GB minimum RAM. For storing text files. And running git diff.

Every page load feels like dial-up. CI/CD pipelines in YAML because apparently everything must be YAML now.

Gitea does the same thing in 100MB. But sure, let’s run the bloated Ruby monstrosity.

Rust Compiler

Takes longer to compile hello world than GCC takes to build the Linux kernel.

Error messages are a novel. “Did you mean to add a lifetime parameter ‘a here?” No, I meant to use C.

The borrow checker is your enemy pretending to be your friend. Fighting with the compiler is not productivity.

Modern C++

C++11 was acceptable. C++23 is insanity.

Templates generating templates generating templates. Compile errors that are 400 lines long. For a typo.

std::unique_ptrstd::vector<std::shared_ptr<Widget>> is not an improvement over Widget**.

Concepts, coroutines, modules, ranges - every three years they add another abstraction layer. The executable size doubles. The compile time triples. The code becomes unreadable.

Just write C.

Webassembly

Running binaries in a browser. We’ve reinvented Flash but worse.

Compiling C to JavaScript bytecode to run in a VM in a browser in a sandbox. Every layer adds overhead. Native code is right there.

“Write once, run everywhere” - heard that before. Java said the same thing. So did Flash. So did Silverlight.

Jupyter Notebooks

Programming for people who are scared of files. Code and output mixed together like some unholy soup.

Version control? Good luck. Debugging? Print statements only. Reproducibility? Depends on what you ran six cells ago.

It’s REPL with extra steps and worse tooling.

Anything that requires a “framework”

React, Angular, Vue, Next.js, [insert this week’s JavaScript framework].

HTML worked. CSS worked. Basic JavaScript worked. Now you need a build system, a bundler, a transpiler, and a PhD to display a form.

The web was documents. Now it’s applications. Bad applications. That take 30 seconds to load and break the back button.

Software that doesn’t suck (much)

Note

This list is incomplete. New garbage is released daily.

If your software needs a conference, it’s too complicated. If your software needs certification, it’s too complicated. If your software has a mascot, you’re compensating for something.

Found a typo? Good for you. Send a patch. Disagree? Write your own list.