Boring Tech Is Stifling Improvement
yonkeltron.com
yonkeltron.com
If the essay had come out in 2008, Ruby on Rails would’ve been the “exciting” thing it was calling out. But instead, Ruby on Rails is generally considered in the “boring” camp, while things that came out closer to the essay’s publication like React are in a state of “Permanent Shiny”.
All of which blinds people to the fact that the web space has in fact settled down years ago and is not in the state of immense flux that actually was happening in 2015.
Write boring code is about going down paths that are well troddened enough that they paved a sidewalk which isn't going anywhere any time soon. Most of the frontend world can't even conceive of an LTS release right now.
I genuinely don't understand the author, choosing boring technology is about making choices so that that platform on which you stand is rock-solid. It's easier to exercise fun, creativity, and new ideas on such a platform because there aren't any sharp edges and you can start pushing a technology. The examples with introducing Kotlin or Python/PL seemingly aren't motivated by anything other than "they're new." What problem are they solving and do you have that problem?
Except it was not required. Class components still work exactly as they did back then.
Stable is being able to set up unattended upgrades on Ubuntu LTS fearlessly. When was the last time you worried about your kernel update?
I didn't say "never update", I said that if you don't need the new features then don't upgrade. If you do need the new features then I don't understand what the problem is.
> Stable is being able to set up unattended upgrades on Ubuntu fearlessly.
lol what? I've never had a system survive an Ubuntu upgrade without breaking something.
True of every software platform in existence.
On the scale of upgrade complexity, react is a walk in the park compared to e.g. everything in the android and ios world, or e.g. any application written for a desktop platform. Ever tried upgrading a C++ app? It's a nightmare beyond anything I've ever faced in my career.
I've never worked with Rust in a professional environment, but I've been a big fan of it for my personal projects for some years now, however, the introduction of async was a massive disruption to the entire ecosystem.
In my opinion, complaining about JS complexity in particular reflects ignorance of the wider software world.
Perl code doesn't work today just as well as it didn't work 20 years ago.
That's not the case with React or most of the js frameworks
.net??? I worked with .net for about 10 years and over multiple versions of .net and .net core, the amount of time we spent facilitating upgrades was much more than I ever spent on upgrading a react app. In fact, at my last .net job I was hired specifically to transition the company's platform from .net to .net core. There was so much work involved that they literally created a role for it.
I can see this being the case if the codebase wasn't in a good state which is a problem of its own. But with proper separation layers. There is not much you have to update in a net framework 472 library project to move it to a net core library project which should contain most of your logic and be tech agnostic anyway. Most of the work is likely to be in the technology dependent projects (web projects and that kind). The common language features remain virtually unchanged. In a front-end project this is much harder, as that kind of abstraction is much harder to come across as the language and technology are tightly coupled.
In an ideal world, your component logic is tech agnostic and should work unchanged in React, Angular, Vue, etc. But in real life, you write your logic using the relevant tech and then when that tech breaks some keyword or how to do x, your app breaks in 50 components and you have to go and make the change manually in all those 50 components.
It's easier to exercise fun, creativity, and new
ideas on such a platform because there aren't any
sharp edges and you can start pushing a technology.
You absolutely can/should/must use more exciting things if they are relevant to whatever unique problem you're trying to solve.
But everything else possible in your stack (particularly foundational elements) should be as boring as possible - i.e. unless you are specifically innovating in the area of RDBMS systems, you should be choosing a "boring" existing RDBMS.
Your point is like saying C is a lightweight language. It sure is, until you have layered everything else you need on top of it.
Saying react is complex is much like saying C is complex because of OpenGL or SDL.
React isn't the ecosystem anymore than C is.
I'm literally on a meeting now trying to work out how to make it boring again.
Before modern web dev practices my team was notified a dev had started the wipe/reinstall OS process on a 1,000 bare metal lab desktops and servers due to a bug in their deployment script
From prior experience I knew only the OS partition had been nuked so far not old data. So my team collected the disks, closed a campus computer, connected disks via USB adapters, shorted the two pins on ATX power supplies to provide power to the disks and booted from the lab machines it was all connected to into a live USB Linux system where we ran recovery tools on ~600-700 SATA disks (some servers had been snapshotted to backup and didn’t need the effort)
That was the most interesting day in tech I’ve ever worked and I started my career designing add on boards for a company that sold to Nortel before they imploded; my output literally shipped late 90s-early 00s internet users packets around
Noodling if else and for loops day in and day around some biz context I don’t care about but some Harvard grad has seed money to advertise is the lamest; the 2010s, an entire decade if my career and since, has been really boring.
--
The biggest change in the last few years has been a shift from Webpack to Vite, which, IMO, is a breath of fresh air.
"Boring" is malleable. If your team is full of React experts, React is boring.
If your team is full of backend-oriented engineers who rarely deal with the frontend, React is much less boring.
"Boring" is also not binary; it is continuous. The mix of technologies in your stack culminate in some arbitrary measure of boringness. This measure can also be thought of as the degree to which teams choose cutting/bleeding edge technologies. If the mix is mostly cutting/bleeding edge, it's very likely that production support is not boring, and problems operating the stack in production are not boring.
Choosing boring technology is also not a panacea that solves every team's problems. Although doing so likely mitigates them.
The fact is that people are tired of meme driven architecture. I don't care that conferences and blogs gave you this great architecture idea. I've tried it before and it sucked. Most of my career has been spent arguing against people trying to expand the amount of work we need to do to accomplish business goals.
I know it's fun to try new languages and design concepts. I did it at the beginning of my career. Everyone should do it. But being a senior engineer is not your chance to try out your pet ideas. It's time to build things efficiently and economically.
If you know something is a temporary repair and time is the most important consideration, you can take risks or shortcuts (crushed stone wasn't available) because you know it's not a permanent fix.
while I could agree on the "principles", specifically for this example I still have scars. Too much costs, no much gain, and you end up with a single project (the first and last one) that no one want to touch and that will be the first to be "engineered back" to java - years later and with a lot of loss
There is more than one cause, but an "innovative" project in 2010 might now just look like a trap with ancient technology. They often do not age well. So, if you aren't prepared to fail fast and rewrite them a few years later -- and many orgs are not -- this can be a problematic path.
"Mainstream" solutions may also be traps, but they are traps you can hire people to maintain or upgrade.
I think you can survive adopting, say, an unpopular language if you are willing to commit and hire-to-train for it, but it takes some focus and commitment, which can be difficult to get executive backing for in many shops. But one-off experiments with the tech stack can be risky unless you can really afford to rewrite failures promptly. FANGs can do this, of course, as can many Fortune 500 companies, but the majority of IT shops probably cannot.
Why is there a limit? Because budgets are limited, and products need to be completed.
For example, something like `What about a PostgreSQL operation rewriting SQL stored procedures in PL/Python?` is both provocative (there are good reasons not to thoughtlessly move all your stored procedures to PL/Python) but it's also absolutely a feature of Postgres a company should investigate and understand.
And unless the project is something that nobody’s ever succeeded at in the past due to technical limitations, businesses tend to survive and thrive if they spend their innovation tokens on product instead of tech/infrastructure.
For example, there was an initiative to move from Talend to Azure Data Factory. Devs had to upskill, and it took them several months to deliver something that fails intermittently (with a huge cost behind it), and noone knows how to fix it.
I rewrote the pipeline in 2 hours (as simple Windows Service that parses a file and writes data to a DB), and polished it in around a day or so. Added some informative and error notifications, and we immediately saw benefits.
Innovation is fun, but some things just don't really need much of it. We've known how to do stuff like ETL for decades. We really don't need cloud-hosted solutions behind client secrets and gated services to load data into a DB.
Ironically, my boring solution seemed more "innovative" because users can now get customised notifications in different Teams Channels.
"Boring"/"exciting" tech isn't stifling or improving anything. These are orthoganal issues. Innovation can emerge from boring tech.
Just because something is innovative (like in his example introducing kotlin when everyone else is using Java) doesn’t mean it will lead to progress.
there's nuance in everything. But this line is what gets me about this article. Let's not prioritize the "fun" of devs for unnecessary toil of ops/SRE.
This happens all the time in contemporary software.
But in the case of software, the scenario would be different: someone wants Foamed Glass Gravel on their resume, or as an accomplishment for their promo bid. So they do the free trial, and dump proprietary information into a Foamed Glass Gravel SaaS, and deploy a half-baked learning project. Then (most importantly) they hop jobs before the problems are obvious to everyone.
One difference is that, in the case of civil engineering, stakeholders care about maintenance problems and deaths, and the responsible engineers will be hunted down, to be sued and/or jailed. So, if a real engineer chose to sign off on something, it's probably legitimate and aligned.
> Consider cases like introducing Kotlin to gradually level-up a Java shop.
But why? Introducing a second language to do pretty much the same thing is a giant leap in complexity and it's not obvious we'd get something real in return.
> What about a PostgreSQL operation rewriting SQL stored procedures in PL/Python?
Yet again, why? SQL is popular and very well understood, the alternative solution would be less portable and a rewrite would introduce unnecessary risk.
Java was stagnating on Android as well and Kotlin was able to introduce a lot of modern features far more quickly. The only argument to keep with Java is that Java actually seems to be chasing after some of the gains Kotlin made.
[citation_needed]
> Java was stagnating on Android as well and Kotlin was able to introduce a lot of modern features
Java was stagnating on Android because Google was (and is) lagging with implementing newer features. Android 12 only got support for Java 11 ffs...
Interestingly enough with Project Mainline it will be possible to support newer Java versions in Android…
The new app is better, but if a new dev looked at the code base they would suggest a rewrite. I would want to do it too, but I just don't feel like joining that rodeo at the moment.
This cycle will repeat till the end of time.
You don't need to be able to perfectly measure things to have evidence. Evidence might be "We used Y in this other project because <it was good in some way>, and the engineers seem to be able to make changes faster: here's our data." Or "Technology Y is better at <some feature> because it <has more mature libraries, or a better approach to concurrency, or whatever>, so we think it will benefit us."
You don't have to be able to measure everything perfectly to make better decisions.
I think it’d be much better to admit that’s far too expensive and/or nearly impossible, plus probably not something most executives are interested in doing anyway, and back off the whole hyper-“legibility” (bad-)data-based-everything notion. It’s an expensive drag mostly delivering bullshit.
Both problems may be connected by a fundamental failure to appreciate scientific and statistical methods at the level that most high school graduates have been exposed to.
There’re narrow areas of intense competition (though not whole sectors—pockets here and there) keeping everyone really on their A-game I suppose (I’ve not seen it, and I’ve seen some places one might expect it) and then there’s… everything else, where it’s all a clown show of guesswork and lots of energy and money spent pretending. It’s a miracle anything works.
This doesn't mean that you always need to use the newest and flashiest tool (eg. Bash+Awk preprocessing can still be faster than using multiple different packages), but you should still be aware and understand how to make those tradeoffs.
You choose your stack based on your problem statement, and as a business that requires taking both Engineering and Business considerations into account.
On the luddite end, you have a lot of developers who are uncreative and vastly prefer reading code to writing it.
On the other end, you have rewriters who can ONLY read code they've written themselves.
You actually need both types to have a good team.
I'm mostly a Java guy (with occasional dabbing in Python/Rust or some web-y stuff) and recently had to quickly jump into Kotlin codebase and I find it utterly clusterfuck-y... I may felt awesome in Java8 days ages ago but nowadays with nice, steady Java development I don't see much need or appeal of using Kotlin...
I wholeheartedly disagree with the sentiment. However, I will point out that not all tech is built for all purposes.
Just like we wouldn’t praise I-95 being rebuilt with silly putty just because the engineers enjoyed working with silly putty. They used a well-designed solution for a fitting problem.
So too do we need to consider that boring technology is usually the RIGHT choice. But in instances where it’s not, or where it doesn’t matter: knock yourself out! Have fun!
--
Foam glass gravel? If this was an analogous computer software article, it would read
""" ... and in 2023, the team shipped a frontend in record speed using an all-new programming language "JavaScript"... """
Maybe foam glass gravel is new on the scale of construction materials, sure? But it's been used in road construction since the 1990s.
So this article reads a bit... strange to me.
So actually it would be more like
""" ...and in 2096, the team shipped a frontend using an all-new JavaScript framework called Foo, first used in Norway in the late 2050s..."""