List of software development philosophies

Short description: None

Software development

Core activities

* Processes
* Requirements
* Design
* Engineering
* Construction
* Testing
* Debugging
* Deployment
* Maintenance

Paradigms and models

* Agile
* Cleanroom
* Incremental
* Prototyping
* Spiral
* V model
* Waterfall

Methodologies and frameworks

* ASD
* DevOps
* DAD
* DSDM
* FDD
* IID
* Kanban
* Lean SD
* LeSS
* MDD
* MSF
* PSP
* RAD
* RUP
* SAFe
* Scrum
* SEMAT
* TSP
* UP
* XP

Supporting disciplines

* Configuration management
* Documentation
* Software quality assurance (SQA)
* Project management
* User experience

Practices

* ATDD
* BDD
* CCO
* CI
* CD
* DDD
* PP
* SBE
* Stand-up
* TDD

Tools

* Compiler
* Debugger
* Profiler
* GUI designer
* Modeling
* IDE
* Build automation
* Release automation
* Infrastructure as code
* Testing

Standards and Bodies of Knowledge

* BABOK
* CMMI
* IEEE standards
* ISO 9001
* ISO/IEC standards
* PMBOK
* SWEBOK
* ITIL

Glossaries

* Artificial intelligence
* Computer science
* Electrical and electronics engineering

* v
* t
* e

This is a list of approaches, styles, methodologies, 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.[1][2] The trend towards agile methods in software engineering is noticeable,[3] however the need for improved studies on the subject is also paramount.[4][5] 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.[6][7][8][9]

## Contents

* 1 Software development methodologies, guidelines, strategies
* 1.1 Large-scale programming styles
* 1.2 Specification-related paradigms
* 1.3 Comprehensive systems
* 1.4 Rules of thumb, laws, guidelines and principles
* 1.5 Other
* 2 Programming paradigms
* 3 Software development methodologies
* 4 Software development processes
* 5 See also
* 6 Further reading
* 7 Other materials, books, articles, etc.
* 8 References

## Software development methodologies, guidelines, strategies

### 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
* OpenUP
* 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[10] by Mickey W. Mantle, Ron Lichty)
* ACID
* Big ball of mud
* Brooks's law
* C++ Core Guidelines[11] (Stroustrup/Sutter) P1 - P13 Philosophy rules
* CAP theorem
* Code reuse
* Command–query separation (CQS)
* Conways 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[12]
* Don't Make Me Think (Principles of intuitive navigation and information design)[13]
* 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[14]
* Where's the Theory for Software Engineering?[15]
* 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)[16]
* 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)
* Open Unified Process
* 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

## See also

* Anti-pattern
* Coding conventions
* Design pattern
* Programming paradigm
* Software development methodology
* Software development process
* Outline of computer science
* Outline of software engineering
* Outline of computer engineering
* Outline of computer programming
* Outline of software development
* Outline of web design and web development
* Outline of computers
* Category:Programming principles

## Further reading

* ISO/IEC/IEEE 26515:2018(E) - ISO/IEC/IEEE International Standard - Systems and software engineering — Developing information for users in an agile environment[17]

## Other materials, books, articles, etc.

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

## References

1. ↑ Gruszczynski, B. (May 2006). "An overview of the current state of software engineering in embedded automotive electronics". 2006 IEEE International Conference on Electro/Information Technology. pp. 377–381. doi:10.1109/EIT.2006.252190. ISBN 0-7803-9592-1. https://ieeexplore.ieee.org/document/4017727.
2. ↑ Patel, B. K.; Litchfield, V.; Tamanaha, D.; Davis, A. (February 1991). "Real time systems/Software methodologies for large aerospace systems". 1991 IEEE Aerospace Applications Conference Digest. pp. 2/1–2/9. doi:10.1109/AERO.1991.154537. ISBN 0-87942-686-1. https://ieeexplore.ieee.org/document/154537.
3. ↑ Yau, Stephen S; Jia, Xiaoping; Bae, Doo-Hwan (1992-05-01). "Software design methods for distributed computing systems" (in en). Computer Communications. Software aspects of future trends in distributed systems 15 (4): 213–224. doi:10.1016/0140-3664(92)90104-M. ISSN 0140-3664. https://dx.doi.org/10.1016/0140-3664(92)90104-M.
4. ↑ Stavru, Stavros (2014-08-01). "A critical examination of recent industrial surveys on agile method usage" (in en). Journal of Systems and Software 94: 87–97. doi:10.1016/j.jss.2014.03.041. ISSN 0164-1212. https://www.sciencedirect.com/science/article/pii/S0164121214000764.
5. ↑ Dybå, Tore; Dingsøyr, Torgeir (2008-08-01). "Empirical studies of agile software development: A systematic review" (in en). Information and Software Technology 50 (9): 833–859. doi:10.1016/j.infsof.2008.01.006. ISSN 0950-5849. https://www.sciencedirect.com/science/article/pii/S0950584908000256.
6. ↑ Taylor, P. (November 2011). "Designerly thinking: What software methodology can learn from design theory". Proceedings International Conference on Software Methods and Tools. SMT 2000. pp. 107–116. doi:10.1109/SWMT.2000.890426. ISBN 978-0-7695-0903-7. https://ieeexplore.ieee.org/document/890426.
7. ↑ Yau, Stephen S; Jia, Xiaoping; Bae, Doo-Hwan (1992-05-01). "Software design methods for distributed computing systems" (in en). Computer Communications. Software aspects of future trends in distributed systems 15 (4): 213–224. doi:10.1016/0140-3664(92)90104-M. ISSN 0140-3664. https://dx.doi.org/10.1016/0140-3664(92)90104-M.
8. ↑ Gomaa, Hassan (1994-05-01). "Software design methods for the design of large-scale real-time systems" (in en). Journal of Systems and Software 25 (2): 127–146. doi:10.1016/0164-1212(94)90002-7. ISSN 0164-1212. https://dx.doi.org/10.1016/0164-1212(94)90002-7.
9. ↑ Budgen, David (July 1995). "'Design models' from software design methods" (in en). Design Studies 16 (3): 293–325. doi:10.1016/0142-694X(95)00001-8. ISSN 0142-694X. https://www.sciencedirect.com/science/article/abs/pii/0142694X95000018.
10. ↑ Mantle, Mickey W. (2020). Managing the unmanageable : rules, tools, and insights for managing software people and teams. Ron Lichty (2nd ed.). Boston. ISBN 978-0-13-566763-7. OCLC 1137802633. https://www.worldcat.org/oclc/1137802633.
11. ↑ "C++ Core Guidelines". http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-philosophy.
12. ↑ Davis, Alan Mark. (1995). 201 principles of software development. New York: McGraw-Hill. ISBN 0-07-015840-1. OCLC 31814837.
13. ↑ Krug, Steve (2014). Don't make me think, revisited : a common sense approach to Web usability. Bayle, Elisabeth,, Straiger, Aren,, Matcho, Mark (Third ed.). [San Francisco, California]. ISBN 978-0-321-96551-6. OCLC 859556499.
14. ↑ Turner, Raymond; Angius, Nicola (2020), Zalta, Edward N., ed., The Philosophy of Computer Science (Spring 2020 ed.), Metaphysics Research Lab, Stanford University, https://plato.stanford.edu/archives/spr2020/entries/computer-science/, retrieved 2020-09-01
15. ↑ Johnson, Pontus; Ekstedt, Mathias; Jacobson, Ivar (2012). "Where's the Theory for Software Engineering?". IEEE Software 29 (5): 96. doi:10.1109/MS.2012.127. ISSN 0740-7459.
16. ↑ Aslett, M. J. (December 1991). "An overview of the HOOD method". 1991 IEE Colloquium on an Introduction to Software Design Methodologies (Ref. No: 1991/181): 5/1–5/4. https://ieeexplore.ieee.org/document/182226.
17. ↑ ISO/IEC/IEEE International Standard - Systems and software engineering — Developing information for users in an agile environment. Iso/Iec/IEEE 26515:2018(E). December 2018. pp. 1–32. doi:10.1109/IEEESTD.2018.8584455. ISBN 978-1-5044-5297-7. https://ieeexplore.ieee.org/document/8584455.

* v
* t
* e

Software engineering

Fields|

* Computer programming
* Requirements engineering
* Software deployment
* Software design
* Software maintenance
* Software testing
* Systems analysis
* Formal methods

Concepts|

* Data modeling
* Enterprise architecture
* Functional specification
* Modeling language
* Orthogonality
* Programming paradigm
* Software
* Software archaeology
* Software architecture
* Software configuration management
* Software development methodology
* Software development process
* Software quality
* Software quality assurance
* Software verification and validation
* Structured analysis

Orientations|

* Agile
* Aspect-oriented
* Object orientation
* Ontology
* Service orientation
* SDLC

Models|

| Developmental|

* Agile
* EUP
* Executable UML
* Incremental model
* Iterative model
* Prototype model
* RAD
* UP
* Scrum
* Spiral model
* V-Model
* Waterfall model
* XP

|

Other|

* SPICE
* CMMI
* Data model
* ER model
* Function model
* Information model
* Metamodeling
* Object model
* Systems model
* View model

Languages|

* IDEF
* UML
* USL
* SysML

Software
engineers

* Victor Basili
* Kent Beck
* Grady Booch
* Fred Brooks
* Barry Boehm
* Peter Chen
* Danese Cooper
* Ward Cunningham
* Tom DeMarco
* Edsger W. Dijkstra
* Delores M. Etter
* Martin Fowler
* Adele Goldstine
* Margaret Hamilton
* C. A. R. Hoare
* Lois Haibt
* Mary Jean Harrold
* Grace Hopper
* Watts Humphrey
* Michael A. Jackson
* Ivar Jacobson
* Alan Kay
* Nancy Leveson
* Stephen J. Mellor
* Bertrand Meyer
* David Parnas
* Trygve Reenskaug
* Winston W. Royce
* James Rumbaugh
* Mary Shaw
* Peri Tarr
* Elaine Weyuker
* Niklaus Wirth
* Edward Yourdon

Related fields|

* Computer science
* Computer engineering
* Project management
* Risk management
* Systems engineering

* Category
* Commons

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/List of software development philosophies. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=List_of_software_development_philosophies&oldid=221202"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template