Software Engineering Reports
The 1968/69 NATO Software Engineering Reports
The design of the Mona Lisa
Early FORTRAN Days
What is architecture, how is it different from design
What makes a great software engineer?
Software Essays
The A-Z of Programming Languages: Python
OpenVMS vs. UNIX
Why Software Really Fails And What to Do About It
Computers vs. Cars
Pictures from a developer's life
Kirk McKusick - A Narrative History of BSD 1
Kirk McKusick - A Narrative History of BSD 2
Software Engineering Essays  
The Unix philosophy
The Unix philosophy favors composability as opposed to monolithic design.


The Unix philosophy
The Unix philosophy emphasizes building short, simple, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators. The Unix philosophy favors composability as opposed to monolithic design.

The Unix philosophy, originated by Ken Thompson, is a set of cultural norms and philosophical approaches to developing small yet capable software based on the experience of leading developers of the Unix operating system. Early Unix developers were important in bringing the concepts of modularity and reusability into software engineering practice, spawning a "software tools" movement.

------------------------------------------------------------------------------------------
In October 1984, Brian Kernighan and Rob Pike published a paper called Program Design in the UNIX Environment.
Much of the power of the UNIX operating system comes from a style of program design that makes programs easy to use and, more important, easy to combine with other programs. This style has been called the use of software tools, and depends more on how the programs fit into the programming environment and how they can be used with other programs than on how they are designed internally.

------------------------------------------------------------------------------------------
Doug McIlroy on Unix programming
------------------------------------------------------------------------------------------
Doug McIlroy, then head of the Bell Labs, and inventor of the Unix pipe, summarized the Unix philosophy as follows:

- This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.

------------------------------------------------------------------------------------------
In 1994, Mike Gancarz, sums up The UNIX Philosophy in 9 paramount precepts:
------------------------------------------------------------------------------------------
MG1. Small is beautiful.
MG2. Make each program do one thing well.
MG3. Build a prototype as soon as possible.
MG4. Choose portability over efficiency.
MG5. Store data in flat text files.
MG6. Use software leverage to your advantage.
MG7. Use shell scripts to increase leverage and portability.
MG8. Avoid captive user interfaces.
MG9. Make every program a filter.


------------------------------------------------------------------------------------------
Eric Raymond’s 17 Unix Rules
------------------------------------------------------------------------------------------
In his book The Art of Unix Programming published in 2003, Eric S. Raymond, summarizes the Unix philosophy as KISS Principle of "Keep it Simple, Stupid." He provides a series of design rules:


ER1. Rule of Modularity
Developers should build a program out of simple parts connected by well defined interfaces, so problems are local, and parts of the program can be replaced in future versions to support new features. This rule aims to save time on debugging code that is complex, long, and unreadable.


ER1. Rule of Clarity
Developers should write programs as if the most important communication is to the developer, including themself, who will read and maintain the program rather than the computer. This rule aims to make code readable and comprehensible for whoever works on the code in future.


ER3. Rule of Composition
Developers should write programs that can communicate easily with other programs. This rule aims to allow developers to break down projects into small, simple programs rather than overly complex monolithic programs.


ER4. Rule of Separation
Developers should separate the mechanisms of the programs from the policies of the programs; one method is to divide a program into a front-end interface and back-end engine that interface communicates with. This rule aims to let policies be changed without destabilizing mechanisms and consequently reducing the number of bugs.


ER5. Rule of Simplicity
Developers should design for simplicity by looking for ways to break up program systems into small, straightforward cooperating pieces. This rule aims to discourage developers’ affection for writing “intricate and beautiful complexities” that are in reality bug prone programs.


ER6. Rule of Parsimony
Developers should avoid writing big programs. This rule aims to prevent overinvestment of development time in failed or suboptimal approaches caused by the owners of the program’s reluctance to throw away visibly large pieces of work. Smaller programs are not only easier to optimize and maintain; they are easier to delete when deprecated.


ER7. Rule of Transparency
Developers should design for visibility and discoverability by writing in a way that their thought process can lucidly be seen by future developers working on the project and using input and output formats that make it easy to identify valid input and correct output. This rule aims to reduce debugging time and extend the lifespan of programs.


ER8. Rule of Robustness
Developers should design robust programs by designing for transparency and discoverability, because code that is easy to understand is easier to stress test for unexpected conditions that may not be foreseeable in complex programs. This rule aims to help developers build robust, reliable products.


ER9. Rule of Representation
Developers should choose to make data more complicated rather than the procedural logic of the program when faced with the choice, because it is easier for humans to understand complex data compared with complex logic. This rule aims to make programs more readable for any developer working on the project, which allows the program to be maintained.


ER10. Rule of Least Surprise
Developers should design programs that build on top of the potential users' expected knowledge; for example, ‘+’ should always mean addition in a calculator program. This rule aims to encourage developers to build intuitive products that are easy to use.


ER11. Rule of Silence
Developers should design programs so that they do not print unnecessary output. This rule aims to allow other programs and developers to pick out the information they need from a program's output without having to parse verbosity.


ER12. Rule of Repair
Developers should design programs that fail in a manner that is easy to localize and diagnose or in other words “fail noisily”. This rule aims to prevent incorrect output from a program from becoming an input and corrupting the output of other code undetected.


ER13. Rule of Economy
Developers should value developer time over machine time, because machine cycles today are relatively inexpensive compared to prices in the 1970s. This rule aims to reduce development costs of projects.


ER14. Rule of Generation
Developers should avoid writing code by hand and instead write abstract high-level programs that generate code. This rule aims to reduce human errors and save time.


ER15. Rule of Optimization
Developers should prototype software before polishing it. This rule aims to prevent developers from spending too much time for marginal gains.


ER16. Rule of Diversity
Developers should design their programs to be flexible and open. This rule aims to make programs flexible, allowing them to be used in other ways than their developers intended.


ER17. Rule of Extensibility
Developers should design for the future by making their protocols extensible, allowing for easy plugins without modification to the program's architecture by other developers, noting the version of the program, and more. This rule aims to extend the lifespan and enhance the utility of the code the developer writes.

------------------------------------------------------------------------------------------
DEC
------------------------------------------------------------------------------------------
In 1957 when the pair and Ken's brother Stan went looking for capital, they found that the American business community was hostile to investing in computer companies. Many smaller computer companies had come and gone in the 1950s, wiped out when new technical developments rendered their platforms obsolete, and even large companies like RCA and General Electric were failing to make a profit in the market. The only serious expression of interest came from Georges Doriot and his American Research and Development Corporation (AR&D). Worried that a new computer company would find it difficult to arrange further financing, Doriot suggested the fledgling company change its business plan to focus less on computers, and even change their name from "Digital Computer Corporation".