General Programming
Programming is not merely the act of writing code; it is the craft of building systems that work, make sense, and maintain long-term viability. This page outlines the core concepts of general programming, focusing on theory building, system design, intentionality, and language capabilities.
Programming as Theory Building
The core work of programming goes beyond writing syntax. It is fundamentally an exercise in theory building and understanding.
- System Coherence: Programming is the theory and understanding that gives a software system its coherence.
- Preserving Architecture and Domain: Successful programming involves actively preserving both architectural coherence and deep domain understanding over time.
- More Than Code: Code is just an artifact of the programming process. The real value lies in the developer's conceptual model of how the system works and why it is structured a certain way.
Intentionality and Ethical Considerations
High-quality software is built on deliberate choices and generalized concepts rather than accidental success. Furthermore, ethical considerations must be an integral part of the programming process.
- Avoid Coincidence: Do not "program by coincidence." Every line of code should have a clear, understood purpose.
- Design for the General Case: Program for the general case to ensure code remains flexible and robust under changing requirements.
- Generalizing Concepts: Many programming concepts are highly conceptual and transfer across domains:
- Systems programming concepts generalize widely across all systems-level development.
- Low-level knowledge (such as general ARM programming) transfers seamlessly across different devices.
- Learning low-level foundations, such as using assembly in basic programming, helps connect conceptual dots from high-level code down to the hardware.
- Moral and Ethical Boundaries: Be intentional about deciding your own moral and ethical boundaries up front. Do not settle for compromising principles "just for now."
- Purpose-Driven Development: Program for positive impact, such as building tools to help people and foster human relationships, rather than solely for profit or other potentially harmful applications.
- Resist Dominant Narratives: Do not believe self-serving lies about technologies being "inevitable." You can make deliberate choices and help others to do the same.
Expanding the View of Languages
To grow as a programmer, one must expand how they view and utilize programming languages, and recognize the broader scope of what constitutes "language."
- Discover Language Primitives: A programming language is often capable of far more than a programmer initially realizes. Exploring a language’s core primitives can unlock unexpected power and efficiency.
- Broaden the Definition of Language: Expressing logic is not limited to code; in many ways, "English is just a programming language" used to define requirements, design systems, and communicate intent.
Cultivating Deep Thinking and Craftsmanship
In a world often driven by speed and quantity, it is crucial to cultivate habits that prioritize depth, quality, and human well-being.
- Cultivate Deep Thinking: Carve out distraction-free bubbles for yourself in both space and time to allow for deep cognitive engagement. This might involve consciously opting out of certain technologies or work patterns deemed "critical" by others.
- Care Deeply About Your Craft: Refactor code until it is clear and elegant. Write good documentation for other humans to read.
- Courage to Go Slowly: Have the courage to go slowly, especially when external pressures demand speed and corner-cutting.
- Prioritize People and Justice: Care more about people, relationships, and justice than about profits, code volume, or mere productivity.
- Motivation by Love: Be motivated by love instead of fear.