In the world of software development, few guiding principles have had the same enduring influence as the Unix philosophy.

Born at AT&T Bell Labs in the late 1970s, this philosophy has long been worshiped for its emphasis on simplicity, modularity, and the creation of small, focused solutions.

As we embark on crafting an ecosystem for embedded devices at alpico, we find ourselves drawn to the timeless principles of Unix as we are seeking a development philosophy for ourselves.

The Essence of Unix Philosophy

The Unix philosophy can be summed up into several core principles:

1. Do one thing, and do it well: Each software component should have a single, well-defined purpose, and it should excel in fulfilling that purpose. If a new job arises, build new rather than complicating existing programs by adding new “features”.
2. Write programs to work together: Software components should be designed with interoperability in mind, making it easy to combine them in creative ways.
3. Test early and don’t hesitate to rebuild: Design and build software (even operating systems) with the intent of testing them early, don’t hesitate to throw parts away and rebuild them.
4. Use tools to make the programming easier: Design tools for building, configuring and monitoring software, even if you have to spend additional time on building them, only to throw them away later.

Our Philosophy

We are still way too early too declare anything definite, but we are quite proud of our current draft:

All software should come in small pieces - available to everyone.

This one sentence really sums up what we are about. Complexity, albeit fun when mastered, and especially unnecessarily complex development is what keeps us up at night, thinking which of the many knobs to turn or sliders to slide so the project finally works on that hardware.

Be it intentional or not, when we start reflecting on how we work on a daily basis, and how we structure our projects, we can clearly see how much we are influenced by a 45 years old philosophy.

Prioritizing Simplicity in Complexity

In a technological landscape often marked by complexity, the Unix philosophy has always called for simplicity. We recognize that simplicity is not just a design choice; it’s a necessity, especially in the realm of embedded systems where resources are at a premium. By prioritizing simplicity, we aim to create software that is first and foremost easy to use for us, and other developers.

Modular Design

The Unix philosophy’s advocacy for modular design has deeply influenced how we approach the architecture of alpico. Breaking down our ecosystem into smaller, independent components (…and then breaking those down into even smaller components) aligns with the Unix philosophy’s belief that each component should have a specific purpose and excel at it. This modularity not only enhances adaptability but also fosters an ecosystem where components seamlessly work together and configuration happens at one place, where all components have to fit together.

Don’t Hesitate to Start Over

When developing new software, we often find ourselves presented with a couple of choices:

1. Use an existing solution: Often not an option, because most of them are old, buggy, bloated and hard to configure
2. Rewrite an existing solution: We don’t like to do that. Even though we can get software smaller and easier to use, the amount of work that has to be put into it often doesn’t justify the time put into it (we are a startup with limited resources after all)
3. Write something new: Hard, but a chance to start new, make it work for us and improve on size and functionality

We often opt for the last choice and write the stuff ourselves. There was a time where we wouldn’t even put cargo crates into our rust projects, because we feared the dependencies and overall overhead of third party code.

Continuous Refinement

The Unix philosophy’s principle of testing early and not hesitating to rebuild resonates strongly with our development ethos. We understand that software development is an iterative process, and each iteration brings us closer to the ideal. By embracing continuous refinement we try to ensure that our components are not just static entities but living, evolving solutions. We don’t scare away from throwing stuff out of the window if it doesn’t work for us.

Building Tools for Our Well Being

We view tools not just as utilities but as enablers of technical empowerment. Whether it’s for building, configuring, or monitoring software components, we try to develop the tools we use with simplicity and usability in mind. At the end of the day, we are the ones using them the most, and we like to have tools that just work.

Modularity Should Go All the Way

We are often asked, why we don’t simply declutter the Linux kernel, make it smaller and share it as our own distribution. Our choice of microkernel as a technical solution reflects our effort to return to the roots of the Unix philosophy. The modularity, flexibility, and simplicity inherent in microkernels align with the Unix philosophy’s timeless principles. This technical alignment did not happen by accident, but was a conscious choice that has steered our entire development to the use of smaller and simpler software components.

To Sum It Up

In essence, the Unix philosophy serves as our inspiration for alpico’s journey toward simplicity, modularity, and efficiency in the development of embedded systems.

As we continue shaping our own philosophy, we invite you, the reader, to share your insights and experiences—because, in the spirit of Unix, collaboration fuels progress. What aspects of the Unix philosophy resonate with you, and how do you see them shaping the future of development in embedded systems?

Let us know, and let’s build a shared understanding together.