The Need for Stable Foundations in Software Development
My employer was kind enough to provide me with a top of the line MacBook Pro. It’s a beautiful machine with 6 CPU cores, 32GB of RAM and a 4K display, the most powerful laptop I’ve ever owned and a valuable tool in working from home. However, unfortunately, the slick machine suffers from a number of software problems.
For one, you can charge it using any of the 4 USB-C ports, but you really should only ever charge it from the right side. Another issue I frequently run into is that I have an external monitor, and despite configuring this as my primary display, the dock will randomly jump back to the MacBook’s monitor, until I go into the settings and move the dock to the right, and to the bottom again, at which point it goes back to the external monitor, until the next time it decides to randomly jump ship. A third issue is that whenever I reboot, it stays stuck early in the boot process, displaying the white Apple logo, and does nothing. It doesn’t complete the boot process until I unplug my USB-C devices. There are more problems, I could go on.
Apple isn’t the only one with these kinds of quality assurance problems. I recently installed Windows 8 on an older desktop computer I wanted to give to my mother (she unfortunately couldn’t see herself using Linux). The first thing I did after installing the new OS was to try and run Windows Update. However, it didn’t work, and I was appalled to find that on this version of the OS, Windows Update is broken out of the box. I learned that there was a patch to fix the issue, but the patch didn’t work, it displayed a progress bar that remained perpetually frozen. Online searches revealed that in order to get the patch to work, I had to unplug the ethernet cable.
Why is it that we live in a world riddled with bugs? I think there are a few reasons for this. No doubt, part of the issue is that our competitive capitalist economy makes major software and hardware vendors want to move at breakneck speeds. Technological progress doesn’t nearly justify a new generation of smartphones being released each year, but, fuck the environment, a new product needs to be released in order to maintain interest and keep sales numbers high. We move fast, and in the process, we break things.
I’ve been a user of Ubuntu Linux for over 10 years now. I chose this distribution because, at the time, it was the most popular, and that made it easy to find software, as well as online help if anything ever went wrong. Originally, when I discovered Ubuntu, it used the GNOME desktop, and things worked fairly seamlessly. However, around 2011, Ubuntu began shipping with a different user interface which they called Unity. This new user interface was riddled with bugs, and the reception was horrible. My understanding is that this user interface change cost Ubuntu its spot as the #1 most popular Linux distribution, where it was replaced by Mint, and now MX Linux.
Why did Canonical choose to replace GNOME in the first place? Probably because the first iPad was released in 2010, and at the time, people couldn’t stop talking about how tablet computers were the future. Canonical wanted to capitalize on the latest trend and make Ubuntu more appealing to tablet users. This necessitated a UI redesign with large buttons, something that looked more like iOS. In the process, they seemingly forgot that at the time, there were no tablets to run Ubuntu on, introduced many new bugs, and quickly alienated their existing user base, overwhelmingly running Ubuntu on laptops and desktops.
As of 2020, Ubuntu is back to running GNOME, and the most innovative feature to have been introduced to tablet computers is a detachable external keyboard, effectively turning said tablets into laptops. I don’t want to sound cynical and overly conservative. I love building new things, and I think that reinventing the wheel can be a valuable learning experience, but it seems obvious to me that sometimes, there’s a lot of value in stability and predictability. Some things should be reinvented, but in other cases, things don’t really need to change. We badly need electric cars and green energy, but maybe we don’t need that user interface redesign.
In software and hardware design, the things that we should be the most wary about breaking, are the interfaces that people rely on. APIs are an obvious area where stability is particularly valuable, and backward compatibility is crucial. Linus Torvalds is known to have vehemently defended a policy that the Linux kernel should never break user space. This policy makes sense, considering that the interface that the kernel exposes to software is one of the most basic and foundational APIs there is. If the kernel routinely breaks programs and libraries, that makes it very difficult to build anything on the platform.
It’s not just APIs though, it’s also programming languages. Many languages add new features all the time, and in the process, break existing software. It’s hard to build something when the ground is constantly shifting. Companies large and small, as well as individual developers, spend a huge amount of effort simply reacting to change and fixing what was broken. This has made me think that, when developing and growing a programming language, you’d probably be doing your existing user base a favor by prioritizing, stability, bug fixes and performance improvements over the constant addition of new features.
I think that what motivates the constant new feature additions we see in JavaScript, Python and Ruby and other languages is not purely a desire to help programmers be more productive, but also a drive to keep up with the Joneses and maintain some competitive edge over other languages. Language designers are worried that new users will flock to whichever language has the newest, trendiest features.
There is probably some truth to the idea that many newcomers will go for the latest features. However, on the flip side, I’ve been wondering if there can’t be a competitive edge in designing a language that is minimalistic, stable and slow to evolve by design. My personal preference is for languages that avoid hidden, complex, automagic behavior. I also think that there is value in choosing a syntax and semantics that uses broadly understood primitives. After all, the main value of a language is in being understood.
Pointers Gone Wild 
Agreed on all counts. I even liked the Ubuntu Unity desktop interface, but I tried it every few years and it wasn’t stable for me until 2016 – shortly before development on it was canceled.
I work on a web application that has active subscriber accounts dating back to 2002. We overhauled the user interface in 2015 and gave users an option to switch. A substantial portion of users are still on the original interface and when we hinted at retiring it they howled in protest.
I would add that our industry’s constant push to appear innovative drives a planned obsolescence cycle that’s harmful to both the environment and low income consumers. A mid range smart phone and a dirt cheap desktop from 2012 has dramatically more computing power than any computer I used in the 1990s, but neither can run modern applications so they are recycled or scrapped. It wasn’t profitable for Microsoft, Apple, or Google to make software for those devices as efficient as software for computers from the 1990s, so they ignored them. It’s a constant source of frustration to me – I work in the tech field, I can afford a $2,000 laptop. Many of my friends and relatives cannot afford it, and they have an abysmal computing experience on older devices.
As for programming, regardless of C, Java, and Javascript’s many flaws I think part of their respective wild popularity is a nearly flawless commitment to backwards compatibility. I’m assuming C# has the same advantage, though I haven’t researched it. Python, D, Perl, and Scala popularity have all been harmed by substantial incompatible changes between versions. Only Python seems to be so wildly popular that it hasn’t lost serious ground from it.
A lot of the problem is with the marketing people and developers who are all to keen to create something new, complete with a new set of bugs – As for users to hell with them!
Look at Microsoft going from Windows 7 to Windows 8. The users, hardly anyone wanted it, worse when they got it was unusable, the familiar menu button was gone, you had to try weird mouse movements to do anything, an utter disaster in design and coding – Geeks and marketing gurus at work!
Even with Windows 10 they don’t seem to have learned, adding features for features sake and adding bugs that do damage
If the language world we see C++ (and other languages) being a moving target, pointless new features that only the proposing geeks would like, making it even more complicated, difficult and fragmented to use!
Yes the C++ language needed some changes like smart pointers, auto and a few others changes, but not the continues changes we a seeing.
The KISS Keep it Simple Sir (substituted the rude bit) principle seems to have been well and truly missed in the tech industry!
What do you think of Rust? It’s doing pretty well with regards to stability, in my opinion. After I stopped wrestling with the borrow checker (such an original story, right?) and started following its wise advice, it pretty much became the only language I ever want to touch at the moment. Much better than C++ in every way, and, even though it’s kinda painful to admit after using D for more than 10 years, it’s even better than that for the most part.
Regarding the current sorry state of software development, it is mostly due to these things:
– General lack of discipline in the field
– Rushed deadlines
– Poor and sometimes nonexistent scientific and engineering basis (PHP anyone?)
– Immaturity of the field in general
The first two are mostly due to capitalism, which is all about squeezing every penny you can out of everyone and everything. If you let capitalists do whatever they want, you will swim in toxic and radioactive waste on your way to work, and eat half-spoiled synthetic food lookalikes for dinner, while people “developing” countries work for 20 cents per week and mostly eat air. But hey, everyone can be a millionaire, just create yet another startup or a Kickstarter project, promise a godly app, deliver some crap in a nice wrap, then take the money and hide.
The latter two can only be fixed with time and diligence. Well, money too, of course.
I’ve been meaning to check out Rust, but somewhat afraid that I may run into some of the same issues as with D (changes breaking my software). How convenient is it to link with existing C/C++ libraries from Rust?
I agree that there is a lack of discipline. I think that rushing goes with constant change. We overvalue the newest/latest thing as well. Undervalue stability and reliability.
I took a serious look at picking up Rust in 2017, but it and the cargo/crates.io community is just as bad as the ones that rally around any other contemporary, npm-like packages ecosystem. It’s full of churn. Have a version of the Rust compiler that’s more than a few months old? Now you’re unable to build things because foundational packages eagerly look for any excuse to incorporate latest language features into their codebase. Even the bootstrapping process for the compiler evokes despair. Last I checked, if you wanted to bootstrap the compiler from C/C++, first you’d be met with opposition about whether or not that’s even a good idea, and then pressing on you’ll discover that actually doing it would take days (weeks?) as you incrementally compile each release—and your new, high-spec hardware is going to prove not just helpful, but necessary. For all the sort of academic praise about Rust’s rigor, the Rust community themselves are surprisingly undisciplined, and as welcoming as the community is frequently reported to be, they’re content to act in a way that sets a really exclusionary threshold for what it takes to be a “Rust developer” (in either of the two senses of that phrase).
..and that is one of the reasons why I dropped Python and have been learning and using Lua for personal projects. Another one is that Lua libraries are often tiny and it is quite common to copy them into your own codebase instead of acquiring them through the package manager.
The dock thing isn’t a bug. It’s just a badly designed feature: https://youtu.be/-ynaOUk1lVw
Check out the comments there. It’s full of people who didn’t get it, either.
So, just bad design then.
“However, on the flip side, I’ve been wondering if there can’t be a competitive edge in designing a language that is minimalistic, stable and slow to evolve by design.” – this sounds like a Go language to me. Although I’m not a big fan of it