Building From First Principles

It's fascinating how I sometimes feel caught between two distinct programming worlds. On one side, there's the vibrant online sphere – discussions on platforms like Bluesky, GitHub, and various blogs – where the conversation is often dominated by the newest frameworks, the trendiest libraries, or highly abstract concepts. Then there's the other world I inhabit, shared with my local developer friends. And honestly? They couldn't be more different.

Online vs. Offline Realities

In the online realm, the mere suggestion of building anything substantial without leveraging a major framework is typically met with a mix of bewilderment and outright scorn. "Vanilla JS for an entire UI? Are you serious?" Constructing something with plain JavaScript and integrating a few libraries as needed is immediately labeled as inherently unmaintainable.

However, when I connect with my developer friends, their chosen tech stack is often the most "boring" imaginable. In fact, when questioned about it, they usually just shrug – they simply couldn't care less about the hype. We're not talking about simple demo applications either. The projects they tackle are highly complex, mission-critical applications with real users, designed to achieve concrete business impact. And truly, they excel! These are some of the most robust applications I've ever encountered.

Intentionally Choosing "Boring" Tech

The remarkable aspect is that, despite their lack of reliance on frameworks, these applications are among the most maintainable I've had the pleasure of reviewing. My friends are consistently able to roll out new features much quicker than anyone else I know. We often brainstorm ideas, and a working prototype typically emerges just a few hours later. Throughout my career, I've been fortunate enough to collaborate with such individuals, and these weren't isolated incidents. So, what sets them apart?

The common thread among them is their unwavering commitment to approaching everything from first principles. Their initial thought isn't, "Which framework should I use?" Instead, it's: "What is the actual problem we're trying to solve?" They delve deeply into desired outcomes, user experience, and identifying the simplest, most direct path to achieve their goals. Technology, for them, is merely a means to an end, never an end in itself.

Clarity is Key

Their code perfectly mirrors this philosophy: it's plain, straightforward, and concise, devoid of unnecessary fluff. You can effortlessly read it from top to bottom without constantly jumping around to grasp the bigger picture. There's very little noise; a pragmatic minimalism pervades it. You won't find layers of abstraction built for abstraction's sake. The biggest "debate" – if one could even call it that – typically revolves around optimal data structuring or the precise placement of side effects.

Does this imply that frameworks are inherently bad? Absolutely not, far from it! The online tech discourse simply tends to create a sense of inevitability around particular tools or methodologies. It's my offline peers who consistently remind me that a significant amount of effective software development thrives well beyond the confines of online framework debates.