Software development process

A software development process prescribes a process for developing software. It typically divides an overall
effort into smaller steps or sub-processes that are intended to ensure high-quality results. The process may
describe specific deliverables – artifacts to be created and completed.[1]

Although not strictly limited to it, software development process often refers to the high-level process that
governs the development of a software system from its beginning to its end of life – known as a methodology,
model or framework. The system development life cycle (SDLC) describes the typical phases that a
development effort goes through from the beginning to the end of life for a system – including a software
system. A methodology prescribes how engineers go about their work in order to move the system through its
life cycle. A methodology is a classification of processes or a blueprint for a process that is devised for the
SDLC. For example, many processes can be classified as a spiral model.

Software process and software quality are closely interrelated; some unexpected facets and effects have been
observed in practice.[2]

Methodology
The SDLC drives the definition of a methodology in that a methodology must address the phases of the
SDLC. Generally, a methodology is designed to result in a high-quality system that meets or exceeds
expectations (requirements) and is delivered on time and within budget even though computer systems can be
complex and integrate disparate components.[3] Various methodologies have been devised, including waterfall,
spiral, agile, rapid prototyping, incremental, and synchronize and stabilize.[4]

A major difference between methodologies is the degree to which the phases are sequential vs. iterative. Agile
methodologies, such as XP and scrum, focus on lightweight processes that allow for rapid changes.[5] Iterative
methodologies, such as Rational Unified Process and dynamic systems development method, focus on
stabilizing project scope and iteratively expanding or improving products. Sequential or big-design-up-front
(BDUF) models, such as waterfall, focus on complete and correct planning to guide larger projects and limit
risks to successful and predictable results.[6] Anamorphic development is guided by project scope and adaptive
iterations. In scrum,[7] for example, one could say a single user story goes through all the phases of the SDLC
within a two-week sprint. By contrast the waterfall methodology, where every business requirement is
translated into feature/functional descriptions which are then all implemented typically over a period of
months or longer.

A project can include both a project life cycle (PLC) and an SDLC, which describe different activities.
According to Taylor (2004), "the project life cycle encompasses all the activities of the project, while the
systems development life cycle focuses on realizing the product requirements".[8]

History
The term SDLC is often used as an abbreviated version of SDLC methodology. Further, some use SDLC and
traditional SDLC to mean the waterfall methodology.
According to Elliott (2004), SDLC "originated in the 1960s, to develop large scale functional business systems
in an age of large scale business conglomerates. Information systems activities revolved around heavy data
processing and number crunching routines".[9] The structured systems analysis and design method (SSADM)
was produced for the UK government Office of Government Commerce in the 1980s. Ever since, according to
Elliott (2004), "the traditional life cycle approaches to systems development have been increasingly replaced
with alternative approaches and frameworks, which attempted to overcome some of the inherent deficiencies
of the traditional SDLC".[9] The main idea of the SDLC has been "to pursue the development of information
systems in a very deliberate, structured and methodical way, requiring each stage of the life cycle––from the
inception of the idea to delivery of the final system––to be carried out rigidly and sequentially"[9] within the
context of the framework being applied.

Other methodologies were devised later:

1970s

Structured programming since 1969

Cap Gemini SDM, originally from PANDATA, the first English translation was published in 1974.
SDM stands for System Development Methodology

1980s

Structured systems analysis and design method (SSADM) from 1980 onwards
Information Requirement Analysis/Soft systems methodology

1990s

Object-oriented programming (OOP) developed in the early 1960s and became a dominant
programming approach during the mid-1990s
Rapid application development (RAD), since 1991
Dynamic systems development method (DSDM), since 1994
Scrum, since 1995
Team software process, since 1998
Rational Unified Process (RUP), maintained by IBM since 1998
Extreme programming, since 1999

2000s

Agile Unified Process (AUP) maintained since 2005 by Scott Ambler

Disciplined agile delivery (DAD) Supersedes AUP

2010s

Scaled Agile Framework (SAFe)

Large-Scale Scrum (LeSS)
DevOps
Since DSDM in 1994, all of the methodologies on the above list except RUP have been agile methodologies -
yet many organizations, especially governments, still use pre-agile processes (often waterfall or similar).

Examples
The following are notable methodologies somewhat ordered by popularity.
Agile

Agile software development refers to a group of frameworks based on iterative development, where
requirements and solutions evolve via collaboration between self-organizing cross-functional teams. The term
was coined in the year 2001 when the Agile Manifesto was formulated.

Waterfall

The waterfall model is a sequential development approach, in which development flows one-way (like a
waterfall) through the SDLC phases.

Spiral

In 1988, Barry Boehm published a software system development spiral model, which combines key aspects of
the waterfall model and rapid prototyping, in an effort to combine advantages of top-down and bottom-up
concepts. It emphases a key area many felt had been neglected by other methodologies: deliberate iterative
risk analysis, particularly suited to large-scale complex systems.

Incremental

Various methods combine linear and iterative methodologies, with the primary objective of reducing inherent
project risk by breaking a project into smaller segments and providing more ease-of-change during the
development process.

Prototyping

Software prototyping is about creating prototypes, i.e. incomplete versions of the software program being
developed.

Rapid

Rapid application development (RAD) is a methodology which favors iterative development and the rapid
construction of prototypes instead of large amounts of up-front planning. The "planning" of software
developed using RAD is interleaved with writing the software itself. The lack of extensive pre-planning
generally allows software to be written much faster and makes it easier to change requirements.

Shape Up

Shape Up is a software development approach introduced by Basecamp in 2018. It is a set of principles and
techniques that Basecamp developed internally to overcome the problem of projects dragging on with no clear
end. Its primary target audience is remote teams. Shape Up has no estimation and velocity tracking, backlogs,
or sprints, unlike waterfall, agile, or scrum. Instead, those concepts are replaced with appetite, betting, and
cycles. As of 2022, besides Basecamp, notable organizations that have adopted Shape Up include UserVoice
and Block.[10][11]

Chaos

Chaos model has one main rule: always resolve the most important issue first.

Incremental funding

Incremental funding methodology - an iterative approach.

Lightweight
Lightweight methodology - a general term for methods that only have a few rules and practices.

Structured systems analysis and design

Structured systems analysis and design method - a specific version of waterfall.

Slow programming

As part of the larger slow movement, emphasizes careful and gradual work without (or minimal) time
pressures. Slow programming aims to avoid bugs and overly quick release schedules.

V-Model

V-Model (software development) - an extension of the waterfall model.

Unified Process

Unified Process (UP) is an iterative software development methodology framework, based on Unified
Modeling Language (UML). UP organizes the development of software into four phases, each consisting of
one or more executable iterations of the software at that stage of development: inception, elaboration,
construction, and guidelines.

Comparison
The waterfall model describes the SDLC phases such that each builds on the result of the previous
one.[12][13][14][15] Not every project requires that the phases be sequential. For relatively simple projects,
phases may be combined or overlapping.[12] Alternative methodologies to waterfall are described and
compared below.[16]

Comparison of methodologies
Open proto-
Waterfall RAD OOP JAD End User
source typing

Control Formal MIS Weak Standards Joint User User

Short
Time frame Long Short Medium Any Medium Short –

One or
Users Many Few Few Varies Few One
two
One or
MIS staff Many Few Hundreds Split Few None
two

Transaction/DSS Transaction Both Both Both DSS DSS DSS

Interface Minimal Minimal Weak Windows Crucial Crucial Crucial

Documentation
Vital Limited Internal In Objects Limited Weak None
and training

Integrity and
Vital Vital Unknown In Objects Limited Weak Weak
security
Reusability Limited Some Maybe Vital Limited Weak None
Process meta-models
Some process models are abstract descriptions for evaluating, comparing, and improving the specific process
adopted by an organization.

ISO/IEC 12207

ISO/IEC 12207 is the international standard describing the method to select, implement, and monitor the life
cycle for software.

Capability Maturity Model Integration

The Capability Maturity Model Integration (CMMI) is one of the leading models and is based on best
practices. Independent assessments grade organizations on how well they follow their defined processes, not
on the quality of those processes or the software produced. CMMI has replaced CMM.

ISO 9000

ISO 9000 describes standards for a formally organized process to manufacture a product and the methods of
managing and monitoring progress. Although the standard was originally created for the manufacturing sector,
ISO 9000 standards have been applied to software development as well. Like CMMI, certification with ISO
9000 does not guarantee the quality of the end result, only that formalized business processes have been
followed.

ISO/IEC 15504

ISO/IEC 15504 Information technology—Process assessment, a.k.a. Software Process Improvement

Capability Determination (SPICE), is a framework for the assessment of software processes. This standard is
aimed at setting out a clear model for process comparison. SPICE is used much like CMMI. It models
processes to manage, control, guide, and monitor software development. This model is then used to measure
what a development organization or project team actually does during software development. This information
is analyzed to identify weaknesses and drive improvement. It also identifies strengths that can be continued or
integrated into common practice for that organization or team.

ISO/IEC 24744

ISO/IEC 24744 Software Engineering—Metamodel for Development Methodologies, is a power type-based

metamodel for software development methodologies.

Soft systems methodology

Soft systems methodology is a general method for improving management processes.

Method engineering

Method engineering is a general method for improving information system processes.

See also
Computer-aided software engineering
List of software development philosophies
 Outline of software engineering
Software development effort estimation
Software documentation
Software project management
Software release life cycle

References
1. "Selecting a development approach" (https://web.archive.org/web/20120620212919/http://www.c
ms.gov/Research-Statistics-Data-and-Systems/CMS-Information-Technology/XLC/Downloads/S
electingDevelopmentApproach.pdf) (PDF). Centers for Medicare & Medicaid Services (CMS)
Office of Information Service. United States Department of Health and Human Services (HHS).
March 27, 2008 [Original Issuance: February 17, 2005]. Archived from the original (http://www.c
ms.gov/Research-Statistics-Data-and-Systems/CMS-Information-Technology/XLC/Downloads/S
electingDevelopmentApproach.pdf) (PDF) on June 20, 2012. Retrieved October 27, 2008.
2. Suryanarayana, Girish (2015). "Software Process versus Design Quality: Tug of War?" (https://d
oi.org/10.1109%2FMS.2015.87). IEEE Software. 32 (4): 7–11. doi:10.1109/MS.2015.87 (https://
doi.org/10.1109%2FMS.2015.87).
3. "Systems Development Life Cycle from" (http://foldoc.org/Systems+Development+Life+Cycle).
FOLDOC. Retrieved June 14, 2013.
4. "Software Development Life Cycle (SDLC)" (http://softwarelifecyclepros.com/wp-content/upload
s/2012/05/Tutorial-Software-Development-LifeCycle-SDLC.pdf) (PDF).
softwarelifecyclepros.com. May 2012. Retrieved June 26, 2025.
5. "SDLC Overview: Models & Methodologies" (https://aristeksystems.com/blog/sdlc-overview/).
Retrieved December 12, 2021.
6. Arden, Trevor (1991). Information technology applications. London: Pitman. ISBN 978-0-273-
03470-4.
7. "What is Scrum?" (https://www.scrum.org/resources/what-is-scrum). December 24, 2019.
8. Taylor, James (2004). Managing Information Technology Projects. p. 39.
9. Geoffrey Elliott (2004). Global Business Information Technology: an integrated systems
approach. Pearson Education. p. 87.
10. "Foreword by Jason Fried | Shape Up" (https://basecamp.com/shapeup/0.1-foreword).
basecamp.com. Retrieved September 11, 2022.
11. "Is Shape Up just a nice theory?" (https://www.curiouslab.io/blog/is-shape-up-just-a-nice-theory).
Curious Lab. Retrieved September 12, 2022.
12. US Department of Justice (2003). INFORMATION RESOURCES MANAGEMENT (https://www.j
ustice.gov/archive/jmd/irm/lifecycle/table.htm) Chapter 1. Introduction.
13. Everatt, G.D.; McLeod, R Jr (2007). "Chapter 2: The Software Development Life Cycle" (https://b
ooks.google.com/books?id=z8UdPmvkBHEC&pg=PA29). Software Testing: Testing Across the
Entire Software Development Life Cycle. John Wiley & Sons. pp. 29–58. ISBN 9780470146347.
14. Unhelkar, B. (2016). The Art of Agile Practice: A Composite Approach for Projects and
Organizations (https://books.google.com/books?id=ZqnMBQAAQBAJ&pg=PA56). CRC Press.
pp. 56–59. ISBN 9781439851197.
15. Land, S.K.; Smith, D.B.; Walz, J.W. (2012). Practical Support for Lean Six Sigma Software
Process Definition: Using IEEE Software Engineering Standards (https://books.google.com/book
s?id=SsBF_lVbK_gC&pg=PA341). John Wiley & Sons. pp. 341–3. ISBN 9780470289952.
16. Post, G., & Anderson, D., (2006). Management information systems: Solving business problems
with information technology. (4th ed.). New York: McGraw-Hill Irwin.
External links
Selecting a development approach (http://www.cms.gov/Research-Statistics-Data-and-Systems/
CMS-Information-Technology/XLC/Downloads/SelectingDevelopmentApproach.pdf) Archived (ht
tps://web.archive.org/web/20190102182947/http://www.cms.gov/Research-Statistics-Data-and-S
ystems/CMS-Information-Technology/XLC/Downloads/SelectingDevelopmentApproach.pdf)
January 2, 2019, at the Wayback Machine at cms.hhs.gov.
Gerhard Fischer, "The Software Technology of the 21st Century: From Software Reuse to
Collaborative Software Design" (http://l3d.cs.colorado.edu/~gerhard/papers/isfst2001.pdf)
Archived (https://web.archive.org/web/20090915033939/http://l3d.cs.colorado.edu/~gerhard/pap
ers/isfst2001.pdf) September 15, 2009, at the Wayback Machine, 2001

Retrieved from "https://en.wikipedia.org/w/index.php?title=Software_development_process&oldid=1315015431"