en.unionpedia.org

List of software development philosophies, the Glossary

Index List of software development philosophies

This is a list of approaches, styles, methodologies, and philosophies in software development and engineering.[1]

Table of Contents

  1. 110 relations: Acceptance test-driven development, ACID, Adaptive software development, Agent-oriented programming, Agile software development, Agile unified process, Anti-pattern, Artificial intelligence systems integration, Aspect-oriented programming, Behavior-driven development, Bert Lance, Brooks's law, CAP theorem, Code reuse, Coding conventions, Command–query separation, Component-based software engineering, Continuous test-driven development, Convention over configuration, Conway's law, Cowboy coding, Data-driven programming, Data-oriented design, Domain-driven design, Don't Make Me Think, Don't repeat yourself, Donald Knuth, DWIM, Dynamic systems development method, Egoless programming, Extreme programming, Fail-fast system, Feature-driven development, Formal methods, Functional programming, GRASP (object-oriented design), HOOD method, Human–computer interaction, ICONIX, Inheritance (object-oriented programming), Iterative and incremental development, John Gall (author), Kanban (development), KISS principle, Law of conservation of complexity, Law of Demeter, Lean software development, Lehman's laws of software evolution, Lightweight methodology, Literate programming, ... Expand index (60 more) »

  2. Software development philosophies

Acceptance test-driven development

Acceptance test–driven development (ATDD) is a development methodology based on communication between the business customers, the developers, and the testers. List of software development philosophies and Acceptance test-driven development are software development philosophies.

See List of software development philosophies and Acceptance test-driven development

ACID

In computer science, ACID (atomicity, consistency, isolation, durability) is a set of properties of database transactions intended to guarantee data validity despite errors, power failures, and other mishaps.

See List of software development philosophies and ACID

Adaptive software development

Adaptive software development (ASD) is a software development process that grew out of the work by Jim Highsmith and Sam Bayer on rapid application development (RAD). List of software development philosophies and Adaptive software development are software development process.

See List of software development philosophies and Adaptive software development

Agent-oriented programming

Agent-oriented programming (AOP) is a programming paradigm where the construction of the software is centered on the concept of software agents.

See List of software development philosophies and Agent-oriented programming

Agile software development

Agile software development is an umbrella term for approaches to developing software that reflect the values and principles agreed upon by The Agile Alliance, a group of 17 software practitioners in 2001. List of software development philosophies and Agile software development are software development philosophies and software development process.

See List of software development philosophies and Agile software development

Agile unified process

Agile unified process (AUP) is a simplified version of the rational unified process (RUP) developed by Scott Ambler.

See List of software development philosophies and Agile unified process

Anti-pattern

An anti-pattern in software engineering, project management, and business processes is a common response to a recurring problem that is usually ineffective and risks being highly counterproductive.

See List of software development philosophies and Anti-pattern

Artificial intelligence systems integration

The core idea of artificial intelligence systems integration is making individual software components, such as speech synthesizers, interoperable with other components, such as common sense knowledgebases, in order to create larger, broader and more capable A.I. systems.

See List of software development philosophies and Artificial intelligence systems integration

Aspect-oriented programming

In computing, aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.

See List of software development philosophies and Aspect-oriented programming

Behavior-driven development

Behavior-driven development (BDD) involves naming software tests using domain language to describe the behavior of the code. List of software development philosophies and behavior-driven development are software development philosophies.

See List of software development philosophies and Behavior-driven development

Bert Lance

Thomas Bertram "Bert" Lance (June 3, 1931 – August 15, 2013) was an American businessman who served as director of the Office of Management and Budget under President Jimmy Carter in 1977.

See List of software development philosophies and Bert Lance

Brooks's law

Brooks's law is an observation about software project management that "Adding manpower to a late software project makes it later."Frederick P. Brooks, Jr.

See List of software development philosophies and Brooks's law

CAP theorem

In database theory, the CAP theorem, also named Brewer's theorem after computer scientist Eric Brewer, states that any distributed data store can provide only two of the following three guarantees:; Consistency: Every read receives the most recent write or an error.

See List of software development philosophies and CAP theorem

Code reuse

In software development (and computer programming in general), code reuse, also called software reuse, is the use of existing software, or software knowledge, to build new software, following the reusability principles.

See List of software development philosophies and Code reuse

Coding conventions

Coding conventions are a set of guidelines for a specific programming language that recommend programming style, practices, and methods for each aspect of a program written in that language.

See List of software development philosophies and Coding conventions

Command–query separation

Command-query separation (CQS) is a principle of imperative computer programming.

See List of software development philosophies and Command–query separation

Component-based software engineering

Component-based software engineering (CBSE), also called component-based development (CBD), is a style of software engineering that aims to construct a software system from components that are loosely-coupled and reusable.

See List of software development philosophies and Component-based software engineering

Continuous test-driven development

Continuous test-driven development (CTDD)Madeyski, L. and Kawalerowicz, M. Continuous Test-Driven Development - A Novel Agile Software Development Practice and Supporting Tool, Proceedings of the 8th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE), 2013, Angers, France, 4–6 July 2013: p.260-267. List of software development philosophies and Continuous test-driven development are software development philosophies and software development process.

See List of software development philosophies and Continuous test-driven development

Convention over configuration

Convention over configuration (also known as coding by convention) is a software design paradigm used by software frameworks that attempts to decrease the number of decisions that a developer using the framework is required to make without necessarily losing flexibility and don't repeat yourself (DRY) principles.

See List of software development philosophies and Convention over configuration

Conway's law

Conway's law describes the link between communication structure of organizations and the systems they design.

See List of software development philosophies and Conway's law

Cowboy coding

Cowboy coding is software development where programmers have autonomy over the development process. List of software development philosophies and Cowboy coding are software development philosophies.

See List of software development philosophies and Cowboy coding

Data-driven programming

In computer programming, data-driven programming is a programming paradigm in which the program statements describe the data to be matched and the processing required rather than defining a sequence of steps to be taken.

See List of software development philosophies and Data-driven programming

Data-oriented design

In computing, data-oriented design is a program optimization approach motivated by efficient usage of the CPU cache, often used in video game development.

See List of software development philosophies and Data-oriented design

Domain-driven design

Domain-driven design (DDD) is a major software design approach, focusing on modeling software to match a domain according to input from that domain's experts. List of software development philosophies and domain-driven design are software development philosophies.

See List of software development philosophies and Domain-driven design

Don't Make Me Think

Don't Make Me Think is a book by Steve Krug about human–computer interaction and web usability.

See List of software development philosophies and Don't Make Me Think

Don't repeat yourself

"Don't repeat yourself" (DRY) is a principle of software development aimed at reducing repetition of information which is likely to change, replacing it with abstractions that are less likely to change, or using data normalization which avoids redundancy in the first place.

See List of software development philosophies and Don't repeat yourself

Donald Knuth

Donald Ervin Knuth (born January 10, 1938) is an American computer scientist and mathematician.

See List of software development philosophies and Donald Knuth

DWIM

DWIM (do what I mean) computer systems attempt to anticipate what users intend to do, correcting trivial errors automatically rather than blindly executing users' explicit but potentially incorrect input.

See List of software development philosophies and DWIM

Dynamic systems development method

Dynamic systems development method (DSDM) is an agile project delivery framework, initially used as a software development method. List of software development philosophies and Dynamic systems development method are software development process.

See List of software development philosophies and Dynamic systems development method

Egoless programming

Egoless programming is a style of computer programming in which personal factors are minimized so that quality may be improved. List of software development philosophies and Egoless programming are software development process.

See List of software development philosophies and Egoless programming

Extreme programming

Extreme programming (XP) is a software development methodology intended to improve software quality and responsiveness to changing customer requirements. List of software development philosophies and Extreme programming are software development philosophies.

See List of software development philosophies and Extreme programming

Fail-fast system

In systems design, a fail-fast system is one that immediately reports at its interface any condition that is likely to indicate a failure.

See List of software development philosophies and Fail-fast system

Feature-driven development

Feature-driven development (FDD) is an iterative and incremental software development process.

See List of software development philosophies and Feature-driven development

Formal methods

In computer science, formal methods are mathematically rigorous techniques for the specification, development, analysis, and verification of software and hardware systems. List of software development philosophies and formal methods are software development philosophies.

See List of software development philosophies and Formal methods

Functional programming

In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions.

See List of software development philosophies and Functional programming

GRASP (object-oriented design)

General Responsibility Assignment Software Patterns (or Principles), abbreviated GRASP, is a set of "nine fundamental principles in object design and responsibility assignment" first published by Craig Larman in his 1997 book Applying UML and Patterns.

See List of software development philosophies and GRASP (object-oriented design)

HOOD method

HOOD (Hierarchic Object-Oriented Design) is a detailed software design method.

See List of software development philosophies and HOOD method

Human–computer interaction

Human–computer interaction (HCI) is research in the design and the use of computer technology, which focuses on the interfaces between people (users) and computers.

See List of software development philosophies and Human–computer interaction

ICONIX

ICONIX is a software development methodology which predates both the Rational Unified Process (RUP), Extreme Programming (XP) and Agile software development. List of software development philosophies and ICONIX are software development process.

See List of software development philosophies and ICONIX

Inheritance (object-oriented programming)

In object-oriented programming, inheritance is the mechanism of basing an object or class upon another object (prototype-based inheritance) or class (class-based inheritance), retaining similar implementation.

See List of software development philosophies and Inheritance (object-oriented programming)

Iterative and incremental development

Iterative and incremental development is any combination of both iterative design (or iterative method) and incremental build model for development. List of software development philosophies and iterative and incremental development are software development philosophies.

See List of software development philosophies and Iterative and incremental development

John Gall (September 18, 1925 – December 15, 2014) was an American author, scholar, and pediatrician.

See List of software development philosophies and John Gall (author)

Kanban (development)

Kanban (Japanese:, meaning signboard or billboard) is a lean method to manage and improve work across human systems. List of software development philosophies and Kanban (development) are software development philosophies.

See List of software development philosophies and Kanban (development)

KISS principle

KISS, an acronym for "Keep it simple, stupid!", is a design principle first noted by the U.S. Navy in 1960. List of software development philosophies and KISS principle are software development philosophies.

See List of software development philosophies and KISS principle

Law of conservation of complexity

The law of conservation of complexity, also known as Tesler's Law, or Waterbed Theory, is an adage in human–computer interaction stating that every application has an inherent amount of complexity that cannot be removed or hidden. List of software development philosophies and law of conservation of complexity are software development philosophies.

See List of software development philosophies and Law of conservation of complexity

Law of Demeter

The Law of Demeter (LoD) or principle of least knowledge is a design guideline for developing software, particularly object-oriented programs.

See List of software development philosophies and Law of Demeter

Lean software development

Lean software development is a translation of lean manufacturing principles and practices to the software development domain. List of software development philosophies and lean software development are software development philosophies.

See List of software development philosophies and Lean software development

Lehman's laws of software evolution

In software engineering, the laws of software evolution refer to a series of laws that Lehman and Belady formulated starting in 1974 with respect to software evolution.

See List of software development philosophies and Lehman's laws of software evolution

Lightweight methodology

A lightweight methodology is a software development method that has only a few rules and practices, or only ones that are easy to follow. List of software development philosophies and lightweight methodology are methodology, software development philosophies and software development process.

See List of software development philosophies and Lightweight methodology

Literate programming

Literate programming is a programming paradigm introduced in 1984 by Donald Knuth in which a computer program is given as an explanation of how it works in a natural language, such as English, interspersed (embedded) with snippets of macros and traditional source code, from which compilable source code can be generated.

See List of software development philosophies and Literate programming

Logic programming

Logic programming is a programming, database and knowledge representation paradigm based on formal logic.

See List of software development philosophies and Logic programming

Loose coupling

In computing and systems design, a loosely coupled system is one.

See List of software development philosophies and Loose coupling

Minimalism (computing)

In computing, minimalism refers to the application of minimalist philosophies and principles in the design and use of hardware and software. List of software development philosophies and minimalism (computing) are software development philosophies.

See List of software development philosophies and Minimalism (computing)

Model-based systems engineering

Model-based systems engineering (MBSE), according to the International Council on Systems Engineering (INCOSE), is the formalized application of modeling to support system requirements, design, analysis, verification and validation activities beginning in the conceptual design phase and continuing throughout development and later life cycle phases.

See List of software development philosophies and Model-based systems engineering

Modular programming

Modular programming is a software design technique that emphasizes separating the functionality of a program into independent, interchangeable modules, such that each contains everything necessary to execute only one aspect of the desired functionality.

See List of software development philosophies and Modular programming

Ninety–ninety rule

In computer programming and software engineering, the ninety-ninety rule is a humorous aphorism that states: This adds up to 180%, making a wry allusion to the notoriety of software development projects significantly over-running their schedules (see software development effort estimation).

See List of software development philosophies and Ninety–ninety rule

Object-oriented programming

Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data and code: data in the form of fields (often known as attributes or properties), and code in the form of procedures (often known as methods).

See List of software development philosophies and Object-oriented programming

Open–closed principle

In object-oriented programming, the open–closed principle (OCP) states "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification"; that is, such an entity can allow its behaviour to be extended without modifying its source code. List of software development philosophies and open–closed principle are software development philosophies.

See List of software development philosophies and Open–closed principle

Outline of computer engineering

The following outline is provided as an overview of and topical guide to computer engineering: Computer engineering – discipline that integrates several fields of electrical engineering and computer science required to develop computer hardware and software. List of software development philosophies and outline of computer engineering are computing-related lists.

See List of software development philosophies and Outline of computer engineering

Outline of computer programming

The following outline is provided as an overview of and topical guide to computer programming: Computer programming – process that leads from an original formulation of a computing problem to executable computer programs. List of software development philosophies and outline of computer programming are computing-related lists.

See List of software development philosophies and Outline of computer programming

Outline of computer science

Computer science (also called computing science) is the study of the theoretical foundations of information and computation and their implementation and application in computer systems. List of software development philosophies and Outline of computer science are computing-related lists.

See List of software development philosophies and Outline of computer science

Outline of computers

The following outline is provided as an overview of and topical guide to computers: Computers – programmable machines designed to automatically carry out sequences of arithmetic or logical operations.

See List of software development philosophies and Outline of computers

Outline of software development

The following outline is provided as an overview of and topical guide to software development: Software development – development of a software product, which entails computer programming (process of writing and maintaining the source code), and encompasses a planned and structured process from the conception of the desired software to its final manifestation.

See List of software development philosophies and Outline of software development

Outline of software engineering

The following outline is provided as an overview of and topical guide to software engineering: Software engineering – application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is the application of engineering to software. List of software development philosophies and outline of software engineering are computing-related lists.

See List of software development philosophies and Outline of software engineering

Outline of web design and web development

The following outline is provided as an overview of and topical guide to web design and web development, two very related fields: Web design – field that encompasses many different skills and disciplines in the production and maintenance of websites. List of software development philosophies and outline of web design and web development are computing-related lists.

See List of software development philosophies and Outline of web design and web development

Package principles

In computer programming, package principles are a way of organizing classes in larger systems to make them more organized and manageable.

See List of software development philosophies and Package principles

Pair programming

Pair programming is a software development technique in which two programmers work together at one workstation.

See List of software development philosophies and Pair programming

Pareto principle

The Pareto principle may apply to fundraising, i.e. 20% of the donors contributing towards 80% of the total The Pareto principle (also known as the 80/20 rule, the law of the vital few and the principle of factor sparsity) states that for many outcomes, roughly 80% of consequences come from 20% of causes (the "vital few").

See List of software development philosophies and Pareto principle

Parkinson's law

Parkinson's law can refer to either of two observations, published in 1955 by the naval historian C. Northcote Parkinson as an essay in The Economist.

See List of software development philosophies and Parkinson's law

Perl

Perl is a high-level, general-purpose, interpreted, dynamic programming language.

See List of software development philosophies and Perl

Principle of least astonishment

In user interface design and software design, the principle of least astonishment (POLA), also known as principle of least surprise, proposes that a component of a system should behave in a way that most users will expect it to behave, and therefore not astonish or surprise users.

See List of software development philosophies and Principle of least astonishment

Procedural programming

Procedural programming is a programming paradigm, classified as imperative programming, that involves implementing the behavior of a computer program as procedures (a.k.a. functions, subroutines) that call each other.

See List of software development philosophies and Procedural programming

Programming paradigm

A programming paradigm is a relatively high-level way to conceptualize and structure the implementation of a computer program.

See List of software development philosophies and Programming paradigm

Rapid application development

Rapid application development (RAD), also called rapid application building (RAB), is both a general term for adaptive software development approaches, and the name for James Martin's method of rapid development. List of software development philosophies and rapid application development are software development process.

See List of software development philosophies and Rapid application development

Rational unified process

The rational unified process (RUP) is an iterative software development process framework created by the Rational Software Corporation, a division of IBM since 2003.

See List of software development philosophies and Rational unified process

Reactive programming

In computing, reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change.

See List of software development philosophies and Reactive programming

Release early, release often

Release early, release often (also known as ship early, ship often, or time-based releases, and sometimes abbreviated RERO) is a software development philosophy that emphasizes the importance of early and frequent releases in creating a tight feedback loop between developers and testers or users, contrary to a feature-based release strategy. List of software development philosophies and release early, release often are software development philosophies.

See List of software development philosophies and Release early, release often

Robustness principle

In computing, the robustness principle is a design guideline for software that states: "be conservative in what you do, be liberal in what you accept from others".

See List of software development philosophies and Robustness principle

Rubber duck debugging

In software engineering, rubber duck debugging (or rubberducking) is a method of debugging code by articulating a problem in spoken or written natural language.

See List of software development philosophies and Rubber duck debugging

Rule of least power

In programming, the rule of least power is a design principle that "suggests choosing the least powerful language suitable for a given purpose". List of software development philosophies and rule of least power are software development philosophies.

See List of software development philosophies and Rule of least power

Scrum (software development)

Scrum is an agile team collaboration framework commonly used in software development and other industries. List of software development philosophies and Scrum (software development) are software development philosophies.

See List of software development philosophies and Scrum (software development)

Secure by design

Secure by design, in software engineering, means that software products and capabilities have been designed to be foundationally secure. List of software development philosophies and secure by design are software development philosophies and software development process.

See List of software development philosophies and Secure by design

SEMAT

SEMAT (Software Engineering Method and Theory) is an initiative to reshape software engineering such that software engineering qualifies as a rigorous discipline.

See List of software development philosophies and SEMAT

Separation of concerns

In computer science, separation of concerns (sometimes abbreviated as SoC) is a design principle for separating a computer program into distinct sections.

See List of software development philosophies and Separation of concerns

Separation of mechanism and policy

The separation of mechanism and policy is a design principle in computer science.

See List of software development philosophies and Separation of mechanism and policy

Single source of truth

In information science and information technology, single source of truth (SSOT) architecture, or single point of truth (SPOT) architecture, for information systems is the practice of structuring information models and associated data schemas such that every data element is mastered (or edited) in only one place, providing data normalization to a canonical form (for example, in database normalization or content transclusion).

See List of software development philosophies and Single source of truth

Single version of the truth

In computerized business management, single version of the truth (SVOT), is a technical concept describing the data warehousing ideal of having either a single centralised database, or at least a distributed synchronised database, which stores all of an organisation's data in a consistent and non-redundant form.

See List of software development philosophies and Single version of the truth

Software design pattern

In software engineering, a design pattern describes a relatively small, well-defined aspect (i.e. functionality) of a computer program in terms of how to write the code.

See List of software development philosophies and Software design pattern

Software development process

In software engineering, a software development process or software development life cycle is a process of planning and managing software development. List of software development philosophies and software development process are methodology.

See List of software development philosophies and Software development process

Software quality assurance

Software quality assurance (SQA) is a means and practice of monitoring all software engineering processes, methods, and work products to ensure compliance against defined standards.

See List of software development philosophies and Software quality assurance

Software review

A software review is "a process or meeting during which a software product is examined by a project personnel, managers, users, customers, user representatives, or other interested parties for comment or approval".

See List of software development philosophies and Software review

SOLID

In software programming, SOLID is a mnemonic acronym for five design principles intended to make object-oriented designs more understandable, flexible, and maintainable.

See List of software development philosophies and SOLID

Specification by example

Specification by example (SBE) is a collaborative approach to defining requirements and business-oriented functional tests for software products based on capturing and illustrating requirements using realistic examples instead of abstract statements. List of software development philosophies and Specification by example are software development philosophies.

See List of software development philosophies and Specification by example

Steve Krug

Steve Krug (born 1950) is a UX (User Experience) professional based in Chestnut Hill, Massachusetts.

See List of software development philosophies and Steve Krug

Structured systems analysis and design method

Structured systems analysis and design method (SSADM) is a systems approach to the analysis and design of information systems.

See List of software development philosophies and Structured systems analysis and design method

Team programming

In software engineering, team programming is a project management strategy for coordinating task distribution in computer software development projects, which involves the assignment of two or more computer programmers to work collaboratively on an individual sub-task within a larger programming project.

See List of software development philosophies and Team programming

Test-driven development

Test-driven development (TDD) is a way of writing code that involves writing an automated unit-level test case that fails, then writing just enough code to make the test pass, then refactoring both the test code and the production code, then repeating with another new test case. List of software development philosophies and test-driven development are software development philosophies and software development process.

See List of software development philosophies and Test-driven development

Tester-driven development

In software engineering, tester-driven development, or bug-driven development, is an anti-pattern where the requirements are determined by bug reports or test results rather than, for example, the value or cost of a feature. List of software development philosophies and tester-driven development are software development process.

See List of software development philosophies and Tester-driven development

The Art of Computer Programming

The Art of Computer Programming (TAOCP) is a comprehensive monograph written by the computer scientist Donald Knuth presenting programming algorithms and their analysis.

See List of software development philosophies and The Art of Computer Programming

The Cathedral and the Bazaar

The Cathedral and the Bazaar: Musings on Linux and Open Source by an Accidental Revolutionary (abbreviated CatB) is an essay, and later a book, by Eric S. Raymond on software engineering methods, based on his observations of the Linux kernel development process and his experiences managing an open source project, fetchmail. List of software development philosophies and the Cathedral and the Bazaar are software development philosophies.

See List of software development philosophies and The Cathedral and the Bazaar

Unified process

The unified software development process or unified process is an iterative and incremental software development process framework. List of software development philosophies and unified process are software development process.

See List of software development philosophies and Unified process

Uniform access principle

The uniform access principle of computer programming was put forth by Bertrand Meyer (originally in his book Object-Oriented Software Construction).

See List of software development philosophies and Uniform access principle

Unix philosophy

The Unix philosophy, originated by Ken Thompson, is a set of cultural norms and philosophical approaches to minimalist, modular software development. List of software development philosophies and Unix philosophy are software development philosophies.

See List of software development philosophies and Unix philosophy

User-centered design

User-centered design (UCD) or user-driven development (UDD) is a framework of processes (not restricted to interfaces or technologies) in which usability goals, user characteristics, environment, tasks and workflow of a product, service or process are given extensive attention at each stage of the design process.

See List of software development philosophies and User-centered design

Value-driven design

Value-driven design (VDD) is a systems engineering strategy based on microeconomics which enables multidisciplinary design optimization.

See List of software development philosophies and Value-driven design

Waterfall model

The waterfall model is a breakdown of development activities into linear sequential phases, meaning they are passed down onto each other, where each phase depends on the deliverables of the previous one and corresponds to a specialization of tasks. List of software development philosophies and waterfall model are software development philosophies.

See List of software development philosophies and Waterfall model

Web usability

Web usability of a website consists of broad goals of usability, presentation of information, choices made in a clear and concise way, a lack of ambiguity and the placement of important items in appropriate areas as well as ensuring that the content works on various devices and browsers.

See List of software development philosophies and Web usability

Worse is better

Worse is better (also called the New Jersey style) is a term conceived by Richard P. Gabriel in a 1989 essay to describe the dynamics of software acceptance. List of software development philosophies and Worse is better are software development philosophies.

See List of software development philosophies and Worse is better

Yo-yo problem

In software development, the yo-yo problem is an anti-pattern that occurs when a programmer has to read and understand a program whose inheritance graph is so long and complicated that the programmer has to keep flipping between many different class definitions in order to follow the control flow of the program.

See List of software development philosophies and Yo-yo problem

You aren't gonna need it

"You aren't gonna need it" (YAGNI) is a principle which arose from extreme programming (XP) that states a programmer should not add functionality until deemed necessary. List of software development philosophies and You aren't gonna need it are software development philosophies.

See List of software development philosophies and You aren't gonna need it

See also

Software development philosophies

References

[1] https://en.wikipedia.org/wiki/List_of_software_development_philosophies

Also known as Philosophy of software development, Software development philosophy.

, Logic programming, Loose coupling, Minimalism (computing), Model-based systems engineering, Modular programming, Ninety–ninety rule, Object-oriented programming, Open–closed principle, Outline of computer engineering, Outline of computer programming, Outline of computer science, Outline of computers, Outline of software development, Outline of software engineering, Outline of web design and web development, Package principles, Pair programming, Pareto principle, Parkinson's law, Perl, Principle of least astonishment, Procedural programming, Programming paradigm, Rapid application development, Rational unified process, Reactive programming, Release early, release often, Robustness principle, Rubber duck debugging, Rule of least power, Scrum (software development), Secure by design, SEMAT, Separation of concerns, Separation of mechanism and policy, Single source of truth, Single version of the truth, Software design pattern, Software development process, Software quality assurance, Software review, SOLID, Specification by example, Steve Krug, Structured systems analysis and design method, Team programming, Test-driven development, Tester-driven development, The Art of Computer Programming, The Cathedral and the Bazaar, Unified process, Uniform access principle, Unix philosophy, User-centered design, Value-driven design, Waterfall model, Web usability, Worse is better, Yo-yo problem, You aren't gonna need it.