Minimal tooling, maximum clarity
I've been programming for long enough now to have watched several generations of "essential" tools come and go. Build systems that were mandatory are now obscure. Frameworks that seemed inevitable are deprecated. The code that survives is usually the simplest code.
This has made me conservative about dependencies. Not in a dogmatic way—I'll use a library when it genuinely solves a hard problem. But I've learned to be skeptical of tools that promise to make easy things easier.
The real cost
Dependencies have costs that don't appear in the initial decision:
- You have to learn them, and keep learning as they evolve
- They break, and you have to debug code you didn't write
- They get abandoned, and you have to migrate or maintain a fork
- They have opinions that may not match yours
For a research project that needs to work for six months, these costs might be acceptable. For code I hope to maintain for years, they add up.
What I actually use
My current setup is boring by design:
- Python with minimal dependencies for research code
- Plain HTML/CSS for web projects (like this site)
- Make for build automation
- Git for version control
- A good text editor
That's mostly it. When I need something more specialized—PyTorch for ML, NumPy for numerics—I'll use it. But I try to keep the core stack as simple as possible.
The clarity payoff
The benefit isn't just reduced maintenance burden. Simple tools produce simple systems, and simple systems are easier to reason about. When something breaks, I usually know where to look. When I revisit old code, I can understand it.
There's also something satisfying about building things from basic components. You understand what's actually happening. The abstraction isn't hiding complexity you don't understand—it's complexity you chose to encapsulate.
Measure twice, ship once.
I think a lot about this phrase. The temptation is always to move fast, to grab the tool that promises quick results. But the time you save in the first week often costs you in the first year.