List of software development philosophies
From Wikipedia, the free encyclopedia
This is a list of approaches, styles, and philosophies in software development. It contains also software development processes, software development methodologies and single practices, principles and laws.
- Abstraction principle (programming)
- Agent-oriented programming
- Agile software development
- Agile Unified Process (AUP)
- Aspect-oriented Programming (AOP)
- Behavior-driven development (BDD)
- Big Design Up Front (BDUF)
- Black box engineering
- Brooks's law
- Cathedral and the Bazaar (see also Release early, release often (RERO))
- Chief programmer team
- CMMI
- Code and fix
- Code reuse
- Cohesion (computer science)
- Cone of Uncertainty
- Constructionist design methodology (CDM)
- Continuous integration
- Control tables
- Convention over configuration
- Conway's Law
- Coupling (computer programming)
- Cowboy coding
- Crystal Clear
- Dependency injection
- Design competition
- Design-driven development (D3)
- Design Driven Testing (DDT)
- Domain-Driven Design (DDD)
- Design for Test (DFT)
- Don't Make Me Think (book by Steve Krug about human computer interaction and web usability)
- Don't repeat yourself (DRY) or Duplication is Evil (DIE) or Once and Only Once (OAOO), Single Point of Truth (SPoT), Single Source Of Truth (SSOT)
- Dynamic Systems Development Method (DSDM)
- Easier to Ask Forgiveness than Permission (EAFP)
- Encapsulation (computer science)
- Evolutionary prototyping
- Extreme Programming (XP)
- Feature Driven Development (FDD)
- Free software license
- Good Enough For Now (GEFN)
- General Responsibility Assignment Software Patterns (GRASP)
- Hollywood Principle
- Information Hiding
- Interface (computer science)
- Interface (object-oriented programming)
- Inversion of control
- Iterative and incremental development
- Joint application design, aka JAD or "Joint Application Development"
- Kaizen
- Kanban
- KISS principle original (Keep It Simple and Stupid), derogatory (Keep It Simple, Stupid!)
- Law of Demeter (LoD)
- Lean software development
- Lean-To-Adaptive Prototyping in Parallel (L2APP) [1]
- Literate Programming
- Microsoft Solutions Framework (MSF)
- Model-driven architecture (MDA)
- MoSCoW Method
- Open source
- Open/closed principle
- Open Unified Process
- Pair programming
- Principle of least astonishment (POLA/PLA)
- Principle of good enough (POGE)
- Project triangle
- Program optimization
- Program to an interface, not an implementation
- Protocol (object-oriented programming)
- Quick-and-dirty
- Rapid application development (RAD)
- Rapid prototyping
- Rational Unified Process (RUP)
- Refactoring
- Release early, release often (RERO) - see also The Cathedral and the Bazaar
- Responsibility-driven design (RDD)
- the Right thing, or the MIT approach, as contrasted with the New Jersey style, Worse is better.
- Scrum
- Separation of concerns (SoC)
- Service-oriented modeling
- Single responsibility principle
- Software craftsmanship
- Software System Safety
- SOLID (object-oriented design)
- Spiral model
- Stepwise Refinement
- Structured Systems Analysis and Design Method (SSADM)
- SUMMIT Ascendant (now IBM Rational SUMMIT Ascendant)
- Team Software Process (TSP)
- Test-driven development (TDD)
- Type-Generic-Profile (TGP) definition at Wards Wiki
- Two Tracks Unified Process (2TUP)
- Ubuntu philosophy
- Unified Process (UP)
- Unix philosophy
- User-centered design (UCD)
- V-Model
- Hybrid V-Model [2]
- Waterfall model
- Wheel and spoke model
- When it's ready [3]
- Win-Win Model
- Worse is better (New Jersey style, as contrasted with the MIT approach)
- You Aren't Gonna Need It (YAGNI)
- Zero one infinity rule
-
This list is incomplete; you can help by expanding it.
