Standards are a key part of our everyday lives. From waking up in the morning, until we go to bed at night, we continually benefit from the interoperability that comes from being able to take certain things for granted. We couldn’t live our modern lives without the benefits that arise from being able to plug things together and have them “just work”. Whether that’s literally plugging in an AC cord and knowing the power will work, or connecting computers together across a global network and knowing they will be able to communicate, standardization underpins it all.
The best standards are “boring”. They may (hopefully!) be quite rigorous, documented in giant tomes formed from dozens, hundreds, or even thousands of pages, often with references to many other specifications that are incorporated by reference, but successful standards result in that “just works” experience. Some of the best modern technology feels like magic because of the work that went into developing standards and specifications to ensure that all the components would fit together and get out of the way. And when technology gets out of the way, users benefit.
Take for example a morning cup of coffee (with apologies to tea drinkers). First, you add water to the machine. You do this using the faucet, a part of your household plumbing, itself a network formed from standardized piping defined by national codes of correct operation. After adding the water, you add coffee grounds (perhaps after grinding them yourself) to a standard-sized filter placed into the machine. While several sizes of filter exist, you have confidence that any of the desired size will fit into your coffee machine because they are all built to standard specifications.
Once the coffee is added to the machine, you press a button, and a few minutes later – presto! – a fresh pot of java fills the room with a fine aroma. During those few minutes, your coffee machine used electricity to heat an element under the pot and a bubble pump mechanism to cause the water to rise and drip onto the coffee grounds (these machines are pretty great because they do this without any moving parts). That electricity – it was delivered to your home across a national or regional AC grid in which the phase is globally synced such that every one of the generators at each of the power stations was moving in time with every other one.
A morning cup of coffee requires the successful adoption and deployment of countless standards and specifications, all working together in hidden harmony, so that the end result is so fabulously boring. That “just works” experience of hitting a button and getting a cup of coffee at the end. This is what the user wants. They may be curious about how it works, and for that there is countless bedtime reading material available, but in the moment they want the technology to get out of the way and deliver an experience without wondering whether it’s going to work.
In the early days of Arm servers (nearly ten years ago), enthusiasts used technology designed for embedded use serving a single purpose to build machines that showcased what could be possible. Those machines were interesting trailblazing platforms that were very useful, but they were not standardized. They did not “just work” with all of the available software. They ran non-standard versions of Operating Systems that needed to be modified continuously with vendor-specific hacks. Users did not have that delightful “just works” coffee experience.
And then, we made it boring. Over the last ten years, we have come together as an industry to aggressively standardize what it means to be an “Arm server”. There are specifications galore, they have interesting sounding acronyms (SBSA, SBBR…), and there is now an industry-wide Server Ready certification program run by Arm to ensure compliance. With the reason behind this effort being to make things “just work”. Today, you can buy a compatible, certified, Arm server and have confidence that it will run the software that you are used to, with no hidden surprises.
We have come so far since those early days. Once you have a coffee machine that “just works”, you can focus on the taste and quality of the coffee, which is the part you as a customer really care about. There are many kinds of coffee on the market, and they will all brew a cup of java, but they are not all the same. And tastes differ between the many coffee drinkers on the planet, necessitating different roasts and customizations specific to a given market or geography.
It’s like this with servers. We build standards so that we can all run the same software and deliver a baseline experience to customers. We do this so that we can go above and beyond that minimum. We can deliver higher performance than the competition, we can strive to offer enhanced robustness and quality. We can open source the firmware so that you have confidence about what’s really running inside the machine. We can do all this, thanks to the power of standardization that underpins it all.