Philosophy-oriented guidance documents for programming languages are C++ Core Guidelines, SOLID Principles, The Unix Philosophy, React Design Principles, The Codeless Code, and The Node Way. These are widely used as well as followed guidance principles. They indicate the underlying philosophy of their respective programming languages and explain what to do in tight spots.
1. C++ Core Guidelines
- C++ core guidelines have been compiled to help programmers to write simple, more efficient and manageable codes.
- The guidelines have a philosophy section which encapsulates the general philosophy behind C++ coding.
- Some of the principles used are listed below:
- Express ideas directly in code.
- Ideally, a program should be statically type safe.
- What cannot be checked at compile time should be checkable at run time.
- Don’t leak any resources.
2. SOLID Principles
- SOLID Principles are conceptualizations of Robert C. Martin, introduced in his 2000 paper called “Design Principles and Design Patterns.”
- The concept was built further by Michael Feathers.
- The concept of SOLID has been integrated into the object-oriented programming since then.
- The acronym SOLID and the concept it stands for are listed below:
- Single Responsibility
- Liskov Substitution
- Interface Segregation
- Dependency Inversion
- These principles are used by programmers to “create more maintainable, understandable, and flexible software”.
3. The Unix Philosophy
- The Unix Philosophy was written and curated by Ken Thompson.
- Over time, the philosophy has grown vast as the use of Unix has become widespread.
- The Unix philosophy is practical and experience-driven.
- The earliest base of the philosophy were the works of successful programmers like Doug McIlroy, Rob Pike, and Ken Thompson himself.
- Some aphorisms offered by the Unix Philosophy are listed below:
- Clarity is better than cleverness.
- Design for simplicity; add complexity only where you must.
- Robustness is the child of transparency and simplicity.
- Distrust all claims for “one true way”.
4. React Design Principles
- The design principles for React are official documentation of philosophy like guidance principles.
- The document provides a better idea what Node is like and what are its underlying philosophies.
- The Node community takes these guidelines very seriously and avoids taking any approach which violates one or more of them.
- Some principles in the documentation are listed below:
- “Components written by different people should work well together.”
- “When there are multiple abstractions competing, React can’t enforce or take advantage of the properties of either of them. It has to work with the lowest common denominator.”
- “React is pragmatic.”
5. The Codeless Code
- The Codeless Code is written on the lines of Gateless Gate, a Zen Koan collection important to Buddhist Philosophy; about which the author read from Gödel, Escher, Bach. (Source5)
- The book gives coding philosophy in a way similar to fables and koans written by philosophers and thinkers. (Source5)
- The literal wording of the arts and philosophy of Codeless Code sometimes gets a little violent, similar to its inspiration Zen Koans. (Source5)
- Some of the fables from The Codeless Code: (Source5)
- The falling and the rising rain
- You are what you eat
- The recommended approach
6. The Node Way
- The Node Way, in a general sense, is the set of common guidelines and advice that are passed down from programmer to programmer. (Source6)
- Since they have never been officially documented, the author took it upon himself to write and compile The Node Way; which gives a comprehensive and easy-to-grasp tour of the guiding principles and underlying philosophy of Node.
- Some philosophical guidelines of The Node Way:
- Build small modules.
- Build modules to serve a single purpose.
- Leverage I/O, avoid heavy computation.
- Invest in clean async.
- Leverage the ecosystem (or: “There’s a Module for That”)
While locating philosophy based documents which gave guidelines of guidance principles to programmers, we came across a good deal of guidance principle compilations. However, we were not sure of their being philosophy-based and widely used. We therefore checked for the sources manually among them, to square in on those guidance documents which were philosophy-based. To do this, we leveraged a few researched examples as a standard for philosophy-based guidance documents for programmers. Due to this, we were able to finally get a few new source. From the remaining selections, we checked for those which were old, and most cited by programmers of that respective language. We also checked if it is official documentation from the code developers themselves (as was the case with React). In the case of Node, we found that The Node Way was mentioned as a kind of fable in many sources, but not well documented; hence we picked the only source with an ordered structure and documentation to it. The Unix Philosophy and The Codeless Code are created keeping the philosophy in mind, and they were frequently mentioned. The C++ Core Guidelines are universally followed as are the SOLID principles.