list of software development philosophies

    List of software development philosophies GudangMovies21 Rebahinxxi LK21

    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.


    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
    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


    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


    Other materials, books, articles, etc.


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


    References

Kata Kunci Pencarian: list of software development philosophies

list of software development philosophies