The unix philosophy was originated by Ken Thompson and describes a set of cultural norms and approaches to minimalist, modular software development. This philosophy was based on the experience of the leading developers of the unix operating system. In the early days of software, there weren’t as many software tools as there are today – in fact, software tools (that is, tools that software developers use to build software), were not really around, at least not in a form you’d recognize today. Software tools, as envisioned by the original unix developers, were a set of simple tools that could be combined to accomplish a task. These included things like source code editors, compiles, debuggers, and the like. This was also the philosophy for building unix operating systems and is largely still in use today at some level in every major operating system. There are a number of historical descriptions of the unix philosophy, going all the way back to the early 1970s. While emphasizing different points, they all were trying to reach the same result, that is, making it as clean as possible to build software in a modular, transparent, and combinable manner. These approaches favored simplification of code and systems over raw performance (although obviously, performance implications still had to be considered as well). The approach also introduced ideas that we are still refining today, such as early and iterative testing of new ideas, rather than building the entire system before doing any testing at all. They even talked about larger systems being composed of smaller tools with smaller scope being composed together to produce the required functionality. You might recognize the former as sounding similar to what you’ve heard while learning agile and the latter to resembling discussions about the single responsibility principle, as well as microservices. While the unix philosophy is old, it’s still very relevant for the way software is built today. In particular, the lessons of the early unix pioneers will probably always be relevant for software development. They learned the hard way about what is required to make stable, maintainable software for general purpose computing. Even in today’s world of massive, distributed, cloud-based systems, the early lessons from the old unix days are still good ones. After all, you can still see echoes of the unix philosophy in today’s discussions about microservices. This is unlikely to change, even in your lifetime, because these principles are based upon hard won knowledge at a time when computing was very different than today. Links Join Us On Patreon Level Up Financial Planning