Development Principles
Development principles encompass the foundational concepts, practices, and philosophies that underpin the software development process. These principles aim to guide teams in creating software that is robust, maintainable, and aligned with user needs and business objectives.
Purpose
The purpose of development principles is to promote consistency, quality, and efficiency in software development. These principles serve as a guide for development teams to follow best practices and methodologies that lead to the creation of high-quality software products.
Format
Development principles are typically documented in a formal policy or guideline document that is accessible to all members of the product development team. This document outlines the principles in detail and may include examples, templates, or methodologies to support their implementation.
Examples
Code Design Principles
| Principle | Description | Benefits |
|---|---|---|
| SOLID Principles | Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion. A set of five principles for writing maintainable and scalable object-oriented code. | Improves code quality, maintainability, and extensibility. |
| CUPID Principle | Coherence, Usefulness, Performance, Integrity, and Dependability. A set of principles for designing software systems that are coherent, useful, performant, reliable, and secure. | Ensures that software systems meet the needs of users and stakeholders. |
| KISS Principle | Keep It Simple, Stupid. A design principle that states that most systems work best if they are kept simple rather than made complex. | Reduces the risk of errors, improves maintainability, and makes it easier to understand and reason about the code. |
| YAGNI Principle | You Aren't Gonna Need It. A principle that states that a programmer should not add functionality until deemed necessary. | Reduces unnecessary complexity, improves maintainability, and reduces the risk of over-engineering. |
Gitlab
Iteration: We always push ourselves to be iterative, making the minimal viable change that directly achieves our goals. We use established methods like the Architecture Design Workflow for complex initiatives, aiming for efficiency and pragmatism in our iteration plans.
Efficiency: Efficiency is a core value in our engineering discipline, aiming for significant compounding effects over time. We strive to implement things in a way that maximises efficiency in the mid-to-long term without losing sight of short-term goals.
Simplicity: Simplicity is crucial for reliability. We prioritise simple solutions over easy ones, sometimes requiring more effort initially but ensuring greater reliability and ease of use.
Reliability: Reliability means delivering an available and dependable product, with everyone playing a role in maintaining it through planning, implementation, monitoring, and prioritisation of work.
Velocity: Our velocity, characterised by incremental progress from our principles of Iteration and Efficiency, is crucial for maintaining competitive advantage and ensuring the community's contribution remains integral to GitLab.
Predictability: We prioritise technical decisions that ensure GitLab's availability and security, understanding that these are paramount for providing an Enterprise-grade service.
Quality: Quality is a collective responsibility. Everything merged to master should be production-ready, adhering to the principle of releasing only when it's truly ready.
Tesla / SpaceX
Make Your Requirements Less Dumb: Recognise that all requirements may have flaws, regardless of their source. Question the validity and necessity of each requirement, ensuring they're critically evaluated, especially those from authoritative figures.
Try Very Hard to Delete the Part or Process: Foster a bias towards removal rather than addition. Aim to delete unnecessary parts or processes, requiring that any added back are genuinely needed. Assign personal accountability for every requirement or constraint, avoiding anonymous or department-based attributions.
Simplify or Optimise: Prioritise simplification over optimisation. Avoid the common mistake of optimising something that shouldn't exist in the first place. Encourage a broad understanding of the system among all team members, enabling them to recognise and avoid unnecessary optimisations.
Accelerate Cycle Time: Focus on increasing the speed of operations, but only after addressing the need for simplification, deletion, and optimisation. Avoid the pitfall of speeding up inefficient or unnecessary processes.
Automate: Be cautious with automation. It should be the last step after simplifying, deleting unnecessary parts, and optimising the process. Avoid automating processes that are fundamentally flawed or unnecessary.
Intercom
Shape the solution: We never blindly execute on requirements defined by others. We deeply understand the value of our work, and help design solutions which efficiently deliver that value.
Be technically conservative: We like familiar solutions with boring technologies. We reuse the same patterns in different solutions as much as possible.
Build in small steps: Large changes are hard to understand, and harder to debug. We deliver complex changes in a series of small, controlled, easy to understand steps.
Keep it simple: Complexity is the enemy of our ability to move quickly. We will trade off performance, financial cost, and perfect abstraction in order to keep a solution simple.
Work with positivity, pride and love: Software engineering isn’t just about the cold logic of computers. It is an inherently collaborative discipline where great things are only built by high-functioning groups of humans.
Anti-patterns
- Lack of Clarity: Vague or overly broad principles that don’t guide behaviour or decision-making effectively.
- Misalignment: Principles that are not aligned with the actual practices or behaviours within the organisation.