List of software development philosophies

This is a list of approaches, styles, methodologies, and philosophies in software development and engineering. It also contains programming paradigms, software development methodologies, software development processes, and single practices, principles, and laws.

Some of the mentioned methods are more relevant to a specific field than another, such as automotive or aerospace. The trend towards agile methods in software engineering is noticeable, however the need for improved studies on the subject is also paramount. Also note that some of the methods listed might be newer or older or still in use or out-dated, and the research on software design methods is not new and on-going.

Large-scale programming styles

 * Behavior-driven development
 * Design-driven development
 * Domain-driven design
 * Secure by design
 * Test-driven development
 * Acceptance test-driven development
 * Continuous test-driven development
 * Specification by example
 * Data-driven development
 * Data-oriented design

Specification-related paradigms

 * Iterative and incremental development
 * Waterfall model
 * Formal methods

Comprehensive systems

 * Agile software development
 * Lean software development
 * Lightweight methodology
 * Adaptive software development
 * Extreme programming
 * Feature-driven development
 * ICONIX
 * Kanban (development)
 * Unified Process
 * Rational Unified Process
 * Agile Unified Process

Rules of thumb, laws, guidelines and principles

 * 300 Rules of Thumb and Nuggets of Wisdom (excerpt from Managing the Unmanageable - Rules, Tools, and Insights for Managing Software People and Teams by Mickey W. Mantle, Ron Lichty)
 * ACID
 * Big ball of mud
 * Brooks's law
 * C++ Core Guidelines (Stroustrup/Sutter) P1 - P13 Philosophy rules
 * CAP theorem
 * Code reuse
 * Command–query separation (CQS)
 * Conway's law
 * Cowboy coding
 * Do what I mean (DWIM)
 * Don't repeat yourself (DRY)
 * Egoless programming
 * Fail-fast
 * Gall's law
 * General Responsibility Assignment Software Patterns (GRASP)
 * If it ain't broke, don't fix it
 * Inheritance (OOP)
 * KISS principle
 * Law of Demeter, also known as the principle of least knowledge
 * Law of conservation of complexity, also known as Tesler's Law
 * Lehman's laws of software evolution
 * Loose coupling
 * Minimalism (computing)
 * Ninety–ninety rule
 * Open–closed principle
 * Package principles
 * Pareto principle
 * Parkinson's law
 * Principle of least astonishment (POLA)
 * Release early, release often
 * Robustness principle, also known as Postel's law
 * Rule of least power
 * SEMAT
 * Separation of concerns
 * Separation of mechanism and policy
 * Single source of truth (SSOT)
 * Single version of the truth (SVOT)
 * SOLID (object-oriented design)
 * There's more than one way to do it
 * Uniform access principle
 * Unix philosophy
 * Worse is better
 * You aren't gonna need it (YAGNI)

Other

 * Davis 201 Principles of Software Development
 * Don't Make Me Think (Principles of intuitive navigation and information design)
 * The Art of Computer Programming (general computer-science masterpiece by Donald E. Knuth)
 * The Cathedral and the Bazaar - book comparing top-down vs. bottom-up open-source software
 * The Philosophy of Computer Science
 * Where's the Theory for Software Engineering?
 * The Yo-yo problem

Programming paradigms

 * Agent-oriented programming
 * Aspect-oriented programming (AOP)
 * Convention over configuration
 * Component-based software engineering
 * Functional programming (FP)
 * Hierarchical object-oriented design (HOOD)
 * Literate programming
 * Logic programming
 * Modular programming
 * Object-oriented programming (OOP)
 * Procedural programming
 * Reactive programming

Software development methodologies

 * Agile Unified Process (AUP)
 * Constructionist design methodology (CDM)
 * Dynamic systems development method (DSDM)
 * Extreme programming (XP)
 * Iterative and incremental development
 * Kanban
 * Lean software development
 * Model-based system engineering (MBSE)
 * Pair programming
 * Mob programming
 * Rapid application development (RAD)
 * Rational Unified Process (RUP)
 * Rubber duck debugging
 * Scrum
 * Structured systems analysis and design method (SSADM)
 * Unified Process (UP)

Software development processes

 * Active-Admin-driven development (AADD)
 * Behavior-driven development (BDD)
 * Bug-driven development (BgDD)
 * Configuration-driven development (CDD)
 * Readme-driven development (RDD)
 * Design-driven development (D3)
 * Domain-driven design (DDD)
 * Feature-driven development (FDD)
 * Test-driven development (TDD)
 * User-centered design (UCD) (User-Driven Development (UDD))
 * Value-driven design (VDD)
 * Software review
 * Software quality assurance

Other materials, books, articles, etc.

 * Don't Make Me Think (book by Steve Krug about human computer interaction and web usability)