Community hub
0 subscribers7 pages, 0 posts
Recent from talks
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to Software development.
Nothing was collected or created yet.
Software development
View on Wikipediafrom Wikipedia
| Part of a series on |
| Software development |
|---|
Software development is the process of designing, creating, testing, and maintaining software applications to meet specific user needs or business objectives. The process is more encompassing than programming, writing code, in that it includes conceiving the goal, evaluating feasibility, analyzing requirements, design, testing and release. The process is part of software engineering which also includes organizational management, project management, configuration management and other aspects.[1]
Software development involves many skills and job specializations including programming, testing, documentation, graphic design, user support, marketing, and fundraising.
Software development involves many tools including: compiler, integrated development environment (IDE), version control, computer-aided software engineering, and word processor.
The details of the process used for a development effort vary. The process may be confined to a formal, documented standard, or it can be customized and emergent for the development effort. The process may be sequential, in which each major phase (i.e., design, implement, and test) is completed before the next begins, but an iterative approach – where small aspects are separately designed, implemented, and tested – can reduce risk and cost and increase quality.
Methodologies
[edit]
Each of the available methodologies is best suited to specific kinds of projects, based on various technical, organizational, project, and team considerations.[3]
- The simplest methodology is the "code and fix", typically used by a single programmer working on a small project. After briefly considering the purpose of the program, the programmer codes it and runs it to see if it works. When they are done, the product is released. This methodology is useful for prototypes but cannot be used for more elaborate programs.[4]
- In the top-down waterfall model, feasibility, analysis, design, development, quality assurance, and implementation occur sequentially in that order. This model requires one step to be complete before the next begins, causing delays, and makes it impossible to revise previous steps if necessary.[5][6][7]
- With iterative processes these steps are interleaved with each other for improved flexibility, efficiency, and more realistic scheduling. Instead of completing the project all at once, one might go through most of the steps with one component at a time. Iterative development also lets developers prioritize the most important features, enabling lower priority ones to be dropped later on if necessary.[6][8] Agile is one popular method, originally intended for small or medium sized projects, that focuses on giving developers more control over the features that they work on to reduce the risk of time or cost overruns.[9] Derivatives of agile include extreme programming and Scrum.[9] Open-source software development typically uses agile methodology with concurrent design, coding, and testing, due to reliance on a distributed network of volunteer contributors.[10]
- Beyond agile, some companies integrate information technology (IT) operations with software development, which is called DevOps or DevSecOps including computer security.[11] DevOps includes continuous development, testing, integration of new code in the version control system, deployment of the new code, and sometimes delivery of the code to clients.[12] The purpose of this integration is to deliver IT services more quickly and efficiently.[11]
Another focus in many programming methodologies is the idea of trying to catch issues such as security vulnerabilities and bugs as early as possible (shift-left testing) to reduce the cost of tracking and fixing them.[13]
In 2009, it was estimated that 32% of software projects were delivered on time and on budget, and with full functionality. An additional 44% were delivered, but were missing at least one of their features. The remaining 24% were cancelled before release.[14]
Steps
[edit]Software development life cycle refers to the systematic process of developing applications.[15]
Feasibility
[edit]The sources of ideas for software products are plentiful. These ideas can come from market research, including the demographics of potential new customers, existing customers, sales prospects who rejected the product, other internal software development staff, or a creative third party. Ideas for software products are usually first evaluated by marketing personnel for economic feasibility, fit with existing channels of distribution, possible effects on existing product lines, required features, and fit with the company's marketing objectives. In the marketing evaluation phase, the cost and time assumptions are evaluated.[16] The feasibility analysis estimates the project's return on investment, its development cost and timeframe. Based on this analysis, the company can make a business decision to invest in further development.[17] After deciding to develop the software, the company is focused on delivering the product at or below the estimated cost and time, and with a high standard of quality (i.e., lack of bugs) and the desired functionality. Nevertheless, most software projects run late, and sometimes compromises are made in features or quality to meet a deadline.[18]
Analysis
[edit]Software analysis begins with a requirements analysis to capture the business needs of the software.[19] Challenges for the identification of needs are that current or potential users may have different and incompatible needs, may not understand their own needs, and change their needs during the process of software development.[20] Ultimately, the result of analysis is a detailed specification for the product that developers can work from. Software analysts often decompose the project into smaller objects, components that can be reused for increased cost-effectiveness, efficiency, and reliability.[19] Decomposing the project may enable a multi-threaded implementation that runs significantly faster on multiprocessor computers.[21]
During the analysis and design phases of software development, structured analysis is often used to break down the customer's requirements into pieces that can be implemented by software programmers.[22] The underlying logic of the program may be represented in data-flow diagrams, data dictionaries, pseudocode, state transition diagrams, and/or entity relationship diagrams.[23] If the project incorporates a piece of legacy software that has not been modeled, this software may be modeled to help ensure it is correctly incorporated with the newer software.[24]
Design
[edit]Design involves choices about the implementation of the software, such as which programming languages and database software to use, or how the hardware and network communications will be organized. Design may be iterative with users consulted about their needs in a process of trial and error. Design often involves people who are expert in aspects such as database design, screen architecture, and the performance of servers and other hardware.[19] Designers often attempt to find patterns in the software's functionality to spin off distinct modules that can be reused with object-oriented programming. An example of this is the model–view–controller, an interface between a graphical user interface and the backend.[25]
Programming
[edit]The central feature of software development is creating and understanding the software that implements the desired functionality.[26] There are various strategies for writing the code. Cohesive software has various components that are independent from each other.[19] Coupling is the interrelation of different software components, which is viewed as undesirable because it increases the difficulty of maintenance.[27] Often, software programmers do not follow industry best practices, resulting in code that is inefficient, difficult to understand, or lacking documentation on its functionality.[28] These standards are especially likely to break down in the presence of deadlines.[29] As a result, testing, debugging, and revising the code become much more difficult. Code refactoring, for example, adding more comments to the code, is a solution to improve the understandability of the code.[30]
Testing
[edit]Testing is the process of ensuring that the code executes correctly and without errors. Debugging is performed by each software developer on their own code to confirm that the code does what it is intended to. In particular, it is crucial that the software executes on all inputs, even if the result is incorrect.[31] Code reviews by other developers are often used to scrutinize new code added to the project, and according to some estimates dramatically reduce the number of bugs persisting after testing is complete.[32] Once the code has been submitted, quality assurance – a separate department of non-programmers for most large companies – test the accuracy of the entire software product. Acceptance tests derived from the original software requirements are a popular tool for this.[31] Quality testing also often includes stress and load checking (whether the software is robust to heavy levels of input or usage), integration testing (to ensure that the software is adequately integrated with other software), and compatibility testing (measuring the software's performance across different operating systems or browsers).[31] When tests are written before the code, this is called test-driven development.[33]
Production
[edit]Production is the phase in which software is deployed to the end user.[34] During production, the developer may create technical support resources for users[35][34] or a process for fixing bugs and errors that were not caught earlier. There might also be a return to earlier development phases if user needs changed or were misunderstood.[34]
Workers
[edit]Software development is performed by software developers, usually working on a team. Efficient communications between team members is essential to success. This is more easily achieved if the team is small, used to working together, and located near each other.[36] Communications also help identify problems at an earlier stage of development and avoid duplicated effort. Many development projects avoid the risk of losing essential knowledge held by only one employee by ensuring that multiple workers are familiar with each component.[37] Software development involves professionals from various fields, not just software programmers but also product managers who set the strategy and roadmap for the product,[38] individuals specialized in testing, documentation writing, graphic design, user support, marketing, and fundraising. Although workers for proprietary software are paid, most contributors to open-source software are volunteers.[39] Alternately, they may be paid by companies whose business model does not involve selling the software, but something else – such as services and modifications to open source software.[40]
Models and tools
[edit]Computer-aided software engineering
[edit]Computer-aided software engineering (CASE) is tools for the partial automation of software development.[41] CASE enables designers to sketch out the logic of a program, whether one to be written, or an already existing one to help integrate it with new code or reverse engineer it (for example, to change the programming language).[42]
Documentation
[edit]Documentation comes in two forms that are usually kept separate – one intended for software developers, and another made available to the end user to help them use the software.[43][44] Most developer documentation is in the form of code comments for each file, class, and method that cover the application programming interface (API)—how the piece of software can be accessed by another—and often implementation details.[45] This documentation is helpful for new developers to understand the project when they begin working on it.[46] In agile development, the documentation is often written at the same time as the code.[47] User documentation is more frequently written by technical writers.[48]
Effort estimation
[edit]Accurate estimation is crucial at the feasibility stage and in delivering the product on time and within budget. The process of generating estimations is often delegated by the project manager.[49] Because the effort estimation is directly related to the size of the complete application, it is strongly influenced by the addition of features in the requirements—the more requirements, the higher the development cost. Aspects not related to functionality, such as the experience of the software developers and code reusability, are also essential to consider in estimation.[50] As of 2019[update], most of the tools for estimating the amount of time and resources for software development were designed for conventional applications and are not applicable to web applications or mobile applications.[51]
Integrated development environment
[edit]
An integrated development environment (IDE) supports software development with enhanced features compared to a simple text editor.[52] IDEs often include automated compiling, syntax highlighting of errors,[53] debugging assistance,[54] integration with version control, and semi-automation of tests.[52]
Version control
[edit]Version control is a popular way of managing changes made to the software. Whenever a new version is checked in, the software saves a backup of all modified files. If multiple programmers are working on the software simultaneously, it manages the merging of their code changes. The software highlights cases where there is a conflict between two sets of changes and allows programmers to fix the conflict.[55]
View model
[edit]
A view model is a framework that provides the viewpoints on the system and its environment, to be used in the software development process. It is a graphical representation of the underlying semantics of a view.
The purpose of viewpoints and views is to enable human engineers to comprehend very complex systems and to organize the elements of the problem around domains of expertise. In the engineering of physically intensive systems, viewpoints often correspond to capabilities and responsibilities within the engineering organization.[56]
Fitness functions
[edit]Fitness functions are automated and objective tests to ensure that the new developments do not deviate from the established constraints, checks and compliance controls.[57]
Intellectual property
[edit]Intellectual property can be an issue when developers integrate open-source code or libraries into a proprietary product, because most open-source licenses used for software require that modifications be released under the same license. As an alternative, developers may choose a proprietary alternative or write their own software module.[58]
References
[edit]- ^ Dooley 2017, p. 1.
- ^ Dooley 2017, p. 12.
- ^ System Development Methodologies for Web-Enabled E-Business: A Customization Framework Linda V. Knight (DePaul University, USA), Theresa A. Steinbach (DePaul University, USA), and Vince Kellen (Blue Wolf, USA)
- ^ Dooley 2017, pp. 8–9.
- ^ Dooley 2017, p. 9.
- ^ a b Langer 2016, pp. 2–3, 5–6.
- ^ Tucker, Morelli & de Silva 2011, p. 8.
- ^ Dooley 2017, p. 11.
- ^ a b Dooley 2017, p. 13.
- ^ Tucker, Morelli & de Silva 2011, pp. 41–42.
- ^ a b Vishnu 2019, pp. 1–2.
- ^ Laukkanen, Eero; Itkonen, Juha; Lassenius, Casper (2017). "Problems, causes and solutions when adopting continuous delivery—A systematic literature review". Information and Software Technology. 82: 55–79. doi:10.1016/j.infsof.2016.10.001.
- ^ Winters, Manshreck & Wright 2020, p. 17.
- ^ Tucker, Morelli & de Silva 2011, p. 6.
- ^ Saif 2019, pp. 46–47.
- ^ Morris 2001, p. 1.10.
- ^ Langer 2016, p. 7.
- ^ Dooley 2017, pp. 3, 8.
- ^ a b c d Langer 2016, p. 8.
- ^ Langer 2016, pp. 2–3.
- ^ Dooley 2017, pp. 193–194.
- ^ Langer 2016, pp. 103–104.
- ^ Langer 2016, pp. 117, 127, 131, 137, 141.
- ^ Langer 2016, p. 106.
- ^ Dooley 2017, p. 142.
- ^ Tucker, Morelli & de Silva 2011, p. 31.
- ^ Langer 2016, pp. 8–9.
- ^ Tucker, Morelli & de Silva 2011, pp. 31–32.
- ^ Tucker, Morelli & de Silva 2011, pp. 34–35.
- ^ Tucker, Morelli & de Silva 2011, pp. 31–32, 35.
- ^ a b c Langer 2016, p. 9.
- ^ Dooley 2017, p. 272.
- ^ Tucker, Morelli & de Silva 2011, p. 9.
- ^ a b c Langer 2016, p. 10.
- ^ Tucker, Morelli & de Silva 2011, p. 37.
- ^ Dooley 2017, p. 2.
- ^ Winters, Manshreck & Wright 2020, pp. 30–31.
- ^ "What Does a Product Manager Do? And How to Become One". Coursera. 21 January 2025. Retrieved 5 May 2025.
- ^ Tucker, Morelli & de Silva 2011, p. 7.
- ^ Tucker, Morelli & de Silva 2011, pp. 14–15.
- ^ Langer 2016, p. 22.
- ^ Langer 2016, pp. 108–110, 206.
- ^ Tucker, Morelli & de Silva 2011, p. 243.
- ^ Winters, Manshreck & Wright 2020, p. 192.
- ^ Winters, Manshreck & Wright 2020, pp. 193–195.
- ^ Tucker, Morelli & de Silva 2011, p. 143.
- ^ Tucker, Morelli & de Silva 2011, p. 144.
- ^ Winters, Manshreck & Wright 2020, p. 204.
- ^ Saif 2019, pp. 50–51.
- ^ Saif 2019, pp. 52–53.
- ^ Saif 2019, p. 45.
- ^ a b Tucker, Morelli & de Silva 2011, p. 68.
- ^ Dooley 2017, p. 236.
- ^ Dooley 2017, p. 239.
- ^ Dooley 2017, pp. 246–247.
- ^ Edward J. Barkmeyer ea (2003). Concepts for Automating Systems Integration Archived 25 January 2017 at the Wayback Machine NIST 2003.
- ^ Fundamentals of Software Architecture: An Engineering Approach. O'Reilly Media. 2020. ISBN 978-1492043454.
- ^ Langer 2016, pp. 44–45.
Further reading
[edit]- Conde, Dan (2002). Software Product Management: Managing Software Development from Idea to Product to Marketing to Sales. Aspatore Books. ISBN 1587622025.
- Davis, A. M. (2005). Just enough requirements management: Where software development meets marketing. Dorset House Publishing Company, Incorporated. ISBN 0932633641.
- Dooley, John F. (2017). Software Development, Design and Coding: With Patterns, Debugging, Unit Testing, and Refactoring. Apress. ISBN 978-1-4842-3153-1.
- Kit, Edward (1992). Software Testing in The Real World. Addison-Wesley Professional. ISBN 0201877562.
- Hasted, Edward (2005). Software That Sells: A Practical Guide to Developing and Marketing Your Software Project. Wiley Publishing. ISBN 0764597833.
- Hohmann, Luke (2003). Beyond Software Architecture: Creating and Sustaining Winning Solutions. Addison-Wesley Professional. ISBN 0201775948.
- Horch, John W. (March 1995). "Two Orientations On How To Work With Objects". IEEE Software. 12 (2): 117–118. ProQuest 215832531.
- Langer, Arthur M. (2016). Guide to Software Development: Designing and Managing the Life Cycle. Springer. ISBN 978-1-4471-6799-0.
- McCarthy, Jim (1995). Dynamics of Software Development. Microsoft Press. ISBN 1556158238.
- Morris, Joseph M. (2001). Software industry accounting (2nd ed.). John Wiley & Sons. OCLC 53863959.
- Rittinghouse, John (2003). Managing Software Deliverables: A Software Development Management Methodology. Digital Press. ISBN 155558313X.
- Saif, Syed Mohsin (2019). "Software Effort Estimation for Successful Software Application Development". In Vishnu, Pendyala (ed.). Tools and Techniques for Software Development in Large Organizations: Emerging Research and Opportunities: Emerging Research and Opportunities. IGI Global. pp. 45–97. ISBN 978-1-7998-1865-6.
- Tucker, Allen; Morelli, Ralph; de Silva, Chamindra (2011). Software Development: An Open Source Approach. CRC Press. ISBN 978-1-4398-8460-7.
- Vishnu, Pendyala (2019). "Evolution of Integration, Build, Test, and Release Engineering Into DevOps and to DevSecOps". In Vishnu, Pendyala (ed.). Tools and Techniques for Software Development in Large Organizations: Emerging Research and Opportunities: Emerging Research and Opportunities. IGI Global. pp. 1–20. ISBN 978-1-7998-1865-6.
- Wiegers, Karl E. (2005). More About Software Requirements: Thorny Issues and Practical Advice. Microsoft Press. ISBN 0735622671.
- Winters, Titus; Manshreck, Tom; Wright, Hyrum (2020). Software Engineering at Google: Lessons Learned from Programming Over Time. O'Reilly Media, Inc. ISBN 978-1-4920-8276-7.
- Wysocki, Robert K. (2006). Effective Software Project Management. Wiley. ISBN 0764596365.
External links
[edit]
Media related to Software development at Wikimedia Commons
Note: This template roughly follows the 2012 ACM Computing Classification System. | |
| Hardware | |
| Computer systems organization | |
| Networks | |
| Software organization | |
| Software notations and tools | |
| Software development | |
| Theory of computation | |
| Algorithms | |
| Mathematics of computing | |
| Information systems |
|
| Security | |
| Human-centered computing | |
| Concurrency | |
| Artificial intelligence | |
| Machine learning | |
| Graphics | |
| Applied computing |
|
| In development | |
| International | |
|---|---|
| National | |
| Other | |
Software development
View on Grokipediafrom Grokipedia
Software development is the process of planning, creating, designing, coding, testing, deploying, and maintaining software applications, systems, or components that enable computers and devices to perform specific tasks, often following a structured software development life cycle (SDLC) to ensure quality, efficiency, and security.[1][2]
The SDLC provides a framework for managing software projects from inception to retirement, encompassing phases such as requirements analysis, system design, implementation, verification, deployment, and maintenance, which help mitigate risks and align outcomes with user needs and business objectives.[3] Various methodologies guide this process, including the traditional **Waterfall** model, which proceeds sequentially through phases, and iterative approaches like Agile, which emphasize flexibility, collaboration, and incremental delivery through practices such as Scrum or Kanban to adapt to changing requirements.[3]
In contemporary practice, software development increasingly incorporates security from the outset—known as "shifting left"—to address vulnerabilities early, alongside integration with DevOps for continuous integration and delivery (CI/CD), ensuring rapid, reliable releases in diverse domains from enterprise systems to mobile apps.[3] This field underpins modern innovation, powering everything from cloud computing and artificial intelligence to embedded systems in critical infrastructure, with standards like those from IEEE and NIST promoting best practices for scalability, maintainability, and ethical considerations.[3]
In contrast to iterative methods, the traditional interpretation of the Waterfall Model emphasizes phase-locked progression, though the original includes provisions for feedback and refinement.[87]
Introduction
Definition and Scope
Software development is the process of conceiving, specifying, designing, programming, documenting, testing, and bug fixing involved in creating and maintaining applications, frameworks, or other software components.[4] This encompasses a systematic approach to building software that meets user needs, often drawing from engineering principles to ensure reliability, efficiency, and scalability.[5] The scope of software development includes a variety of paradigms and contexts, such as custom software tailored to specific organizational requirements, commercial off-the-shelf (COTS) products designed for broad market use, open-source development where source code is publicly available for collaboration and modification, and embedded systems integrated into hardware for specialized functions like device control.[4] Key concepts distinguish software as a product—typically a standalone, licensed application owned and maintained by the developer, such as mass-produced tools—versus software as a service (SaaS), where functionality is delivered over the internet on a subscription basis without local installation.[6] Unlike hardware engineering, which focuses on designing and fabricating physical components like circuits and processors, software development deals with intangible, logical instructions that run on hardware, emphasizing abstraction, modularity, and iterative refinement over material constraints.[4] Examples of software types developed through these processes include desktop applications for local computing tasks, web applications accessed via browsers for distributed services, mobile applications optimized for handheld devices, and enterprise systems for large-scale organizational operations like resource management.[4] This foundational process relates to the broader software development life cycle, which structures these activities into phases for organized execution.[5]Importance in Modern Society
Software development plays a pivotal role in the global economy, contributing significantly to gross domestic product (GDP) and fostering job creation across diverse sectors. In the United States, as of 2020, the software industry directly contributed $933 billion to the economy, adding $1.9 trillion in total value-added GDP and supporting 15.8 million jobs through direct employment and related economic activities.[7] Globally, the sector drives innovation in industries such as finance, where algorithmic trading systems enhance market efficiency; healthcare, enabling electronic health records and diagnostic tools; and entertainment, powering streaming platforms and interactive media. As of 2024, there were approximately 28.7 million professional software developers worldwide, a figure that underscores the industry's capacity for widespread employment and skill development.[8] Beyond economics, software development facilitates profound societal transformations by enabling digitalization and automation, which streamline daily operations and address pressing global challenges. It underpins digital transformation initiatives, allowing organizations to integrate technologies that automate routine tasks, reduce operational costs, and improve service delivery—for instance, through robotic process automation in logistics and manufacturing. In tackling global issues, software supports climate modeling simulations that predict environmental changes and inform policy decisions, while telemedicine applications expand access to healthcare in remote or underserved areas, mitigating barriers exacerbated by geographic and infrastructural limitations. These applications not only enhance efficiency but also promote sustainability by optimizing resource use and reducing carbon footprints associated with physical travel.[9][10][11] The pervasive dependency on software extends to foundational technologies that shape modern infrastructure, including artificial intelligence (AI), the Internet of Things (IoT), cloud computing, and cybersecurity. Software forms the core of AI systems, enabling machine learning algorithms to process vast datasets for predictive analytics and decision-making. In IoT ecosystems, it orchestrates device connectivity and data flow, supporting smart cities and industrial automation. Cloud computing relies on software for scalable resource management and virtualization, while cybersecurity frameworks use software-driven AI to detect and neutralize threats in real-time, safeguarding digital assets across networks. This interdependence highlights software development's role as the enabler of technological advancement.[12][13][14] The sector's growth trajectory further amplifies its societal importance, with the global software market valued at USD 730.70 billion in 2024 and projected to exceed USD 1.39 trillion by 2030, driven by demand for AI-integrated solutions and cloud-native applications. This expansion, at a compound annual growth rate (CAGR) of 11.3%, reflects innovation in areas like generative AI and edge computing, positioning software development as a key driver of economic resilience and technological sovereignty.[15]History
Origins and Early Practices
The origins of software development trace back to the mid-19th century, predating electronic computers, with foundational concepts emerging from mechanical computing ideas. In 1842–1843, Ada Lovelace appended extensive notes to a translation of an article by Luigi Menabrea on Charles Babbage's proposed Analytical Engine, a hypothetical mechanical general-purpose computer.[16] These notes included what is recognized as the first published algorithm intended for machine implementation—a method to compute Bernoulli numbers—demonstrating early abstraction of programming as a sequence of operations separate from hardware mechanics.[17] Lovelace envisioned the Engine manipulating symbols beyond numerical computation, foreshadowing software's potential for broader applications.[18] The advent of electronic computers in the 1940s marked the shift to practical programming, though initial methods were manual and hardware-dependent. The ENIAC (Electronic Numerical Integrator and Computer), completed in 1945 by John Presper Eckert and John Mauchly at the University of Pennsylvania, was programmed by physically rewiring panels with cables and switches, a labor-intensive process that could take days for each new task.[19] A team of women mathematicians, including Jean Jennings Bartik and Betty Holberton, handled this "hand-wiring," converting mathematical problems into electrical configurations without stored programs or keyboards.[20] This era highlighted programming's nascent challenges, as modifications required physical reconfiguration rather than editable instructions. By the 1950s, advancements introduced symbolic representation and automation, easing the burden of machine-level coding. Assembly languages emerged around 1951, allowing programmers to use mnemonics and symbolic addresses instead of raw binary, as seen in systems like IBM's Symbolic Optimal Assembly Program (SOAP) for the IBM 650 in the mid-1950s.[21] Programs were typically entered via punched cards, where each card held one line of code punched into columns representing characters, a medium adapted from earlier tabulating machines and used extensively on mainframes like the IBM 704.[22] In 1952, Grace Hopper developed the A-0 System, an early compiler for the UNIVAC I that translated symbolic mathematical code into machine instructions via subroutines, laying groundwork for automatic programming.[23] The term "software" was coined in 1958 by statistician John W. Tukey in an article distinguishing programmable instructions from hardware.[24] High-level languages soon followed: FORTRAN (Formula Translation), led by John Backus at IBM, debuted in 1957 as the first compiler for the IBM 704, enabling scientific computations in algebraic notation.[25] COBOL (Common Business-Oriented Language), initiated in 1959 by the Conference on Data Systems Languages (CODASYL) under Hopper's influence, targeted business data processing with English-like syntax for readability across machines.[26] Early practices in the 1950s and 1960s relied on sequential processes, where development proceeded linearly from requirements to coding, testing, and deployment, often using punched cards for batch processing on mainframes.[27] Debugging was arduous without interactive tools, involving manual tracing of errors via printouts or lights, and limited to small teams managing hardware constraints like core memory.[22] By the mid-1960s, escalating complexity in large-scale systems—such as IBM's OS/360 operating system—led to the "software crisis," characterized by projects exceeding budgets, timelines, and reliability expectations.[28] This was formalized at the 1968 NATO Conference on Software Engineering in Garmisch, Germany, where experts documented issues like unreliable code and maintenance burdens in systems for aerospace and defense.[28] These challenges prompted a transition toward structured programming techniques in the following decade.Evolution in the Digital Age
The software crisis of the 1960s, characterized by escalating costs, delays, and reliability issues in large-scale software projects, prompted the NATO conferences on software engineering in 1968 and 1969, which highlighted the need for disciplined approaches and led to the development of formal software development life cycle (SDLC) models to address these challenges.[29] In the 1970s and 1980s, structured programming emerged as a key paradigm shift, influenced by Edsger Dijkstra's 1968 critique of the "goto" statement, which advocated for clearer control structures to improve code readability and maintainability.[30] This was complemented by the rise of object-oriented programming (OOP), exemplified by Smalltalk's development in 1972 at Xerox PARC under Alan Kay, which introduced concepts like classes and inheritance for modular software design.[31] Later, Bjarne Stroustrup released C++ in 1985 at Bell Labs, extending C with OOP features to support larger, more complex systems.[32] The personal computing boom, ignited by the IBM PC's launch in 1981, democratized access to computing power and spurred software development for consumer applications.[33] The 1990s and 2000s saw the internet's expansion transform software practices, beginning with Tim Berners-Lee's invention of the World Wide Web in 1991 at CERN, enabling distributed applications and web-based development.[34] The open-source movement gained momentum with Linus Torvalds' announcement of the Linux kernel in 1991, fostering collaborative development of robust operating systems.[35] This ethos extended to web technologies with the Apache HTTP Server's release in 1995 by a group of developers patching the NCSA HTTPd, which became a cornerstone for server-side software.[36] In response to rigid methodologies, the Agile Manifesto was published in 2001 by a group of software practitioners, emphasizing iterative development, customer collaboration, and adaptability over comprehensive documentation.[37] From the 2010s onward, cloud computing revolutionized infrastructure, with Amazon Web Services (AWS) launching in 2006 to provide scalable, on-demand resources for software deployment.[38] Mobile development exploded following Apple's iOS debut with the iPhone in 2007 and Google's Android OS release in 2008, shifting focus to app-centric ecosystems and touch interfaces.[39][40] The term DevOps, coined by Patrick Debois in 2009 during his organization of the first DevOpsDays conference, integrated development and operations for faster, more reliable releases.[41] More recently, AI integration advanced with GitHub Copilot's 2021 launch by GitHub and OpenAI, using machine learning to suggest code completions and automate routine tasks; by the mid-2020s, generative AI tools like OpenAI's GPT-4 (released 2023) further enabled automated code generation and debugging, enhancing developer productivity.[42][43]Software Development Life Cycle
Planning and Requirements Gathering
Planning and requirements gathering constitutes the foundational phase of the software development life cycle (SDLC), where project objectives are defined, stakeholder needs are identified, and the overall scope is established to guide subsequent development efforts.[44] This phase ensures alignment between business goals and technical deliverables by systematically collecting and documenting what the software must achieve, mitigating risks from misaligned expectations early on.[45] Key activities in this phase include identifying project objectives through initial consultations and eliciting requirements from stakeholders using structured techniques such as interviews and surveys. Interviews allow direct interaction with users to uncover needs, while surveys enable broader input from diverse groups, helping to capture both functional and non-functional requirements efficiently.[45] Once gathered, requirements are prioritized using methods like the MoSCoW technique, which categorizes them into Must have (essential for delivery), Should have (important but not vital), Could have (desirable if time permits), and Won't have (out of scope for the current iteration).[46] This prioritization aids in focusing resources on high-value features and managing expectations.[47] Artifacts produced during planning include requirements specification documents, such as software requirements specifications (SRS) that outline functional, performance, and interface needs in a structured format, and user stories that describe requirements from an end-user perspective in a concise, narrative form like "As a [user], I want [feature] so that [benefit]."[48][49] Use cases may also be documented to detail system interactions, providing scenarios for validation. Feasibility reports assess technical, economic, and operational viability, evaluating whether the project can be realistically implemented within constraints like budget and technology availability.[50] Techniques employed include stakeholder analysis to identify and classify individuals or groups affected by the project based on their influence and interest, ensuring comprehensive input from key parties such as end-users, sponsors, and developers.[51] Risk assessment involves evaluating potential uncertainties in requirements, such as ambiguities or conflicts, to prioritize mitigation strategies early. Prototyping serves as a validation tool, where low-fidelity models are built to elicit feedback and refine requirements iteratively before full design.[52][53] Common pitfalls in this phase encompass scope creep, where uncontrolled additions expand the project beyond original boundaries, and ambiguous requirements that lead to misunderstandings and rework. Issues related to incomplete or changing requirements are among the top contributors to project failures, accounting for approximately 20-25% according to early industry studies like the Standish Group's 1994 CHAOS report, underscoring the need for rigorous documentation and validation.[54] These elements from planning feed into the subsequent analysis and feasibility study phase for deeper technical evaluation.Analysis and Feasibility Study
In the analysis and feasibility study phase of software development, requirements are meticulously evaluated to distinguish between functional requirements, which specify what the system must do (such as processing user inputs or generating reports), and non-functional requirements, which define how the system performs (including attributes like performance, security, and usability).[55] This differentiation ensures that the software meets both operational needs and quality standards, as non-functional aspects often determine overall system success despite frequent oversight in early stages.[56] Functional requirements focus on core behaviors, while non-functional ones address constraints like scalability and reliability, enabling a balanced specification that aligns with stakeholder expectations.[57] Feasibility studies build on this analysis by assessing project viability through technical proof-of-concept prototypes, which validate whether proposed technologies can implement the requirements effectively, and cost-benefit analyses, which weigh anticipated expenses against projected gains to justify resource allocation.[58] Technical feasibility evaluates hardware, software, and expertise availability, often via small-scale implementations to identify risks early.[59] Cost-benefit analysis quantifies economic viability by comparing development costs, including labor and tools, with benefits like efficiency improvements or revenue growth, helping decision-makers approve or pivot projects.[60] Key tools and methods support this phase, including data flow diagrams (DFDs), which visually map how data moves through the system to uncover processing inefficiencies during requirements refinement, and entity-relationship models (ERMs), which diagram data entities and their interconnections to ensure comprehensive coverage of information needs.[61][62] SWOT analysis further aids by systematically identifying internal strengths and weaknesses (e.g., team expertise versus skill gaps) alongside external opportunities and threats (e.g., market trends or regulatory changes) specific to the software project.[63] Outputs from this phase include a refined requirements traceability matrix (RTM), a tabular document linking high-level requirements to detailed specifications and tests to track coverage and changes throughout development, ensuring no gaps in implementation.[64] Gap analysis reports complement this by comparing current requirements against desired outcomes, highlighting discrepancies in functionality or performance to guide revisions.[65] A critical metric in feasibility studies is return on investment (ROI), which measures project profitability. The basic ROI formula is derived from total investment costs (e.g., development, hardware, and training expenses) subtracted from expected returns (e.g., cost savings or revenue increases), then divided by the costs and multiplied by 100 to yield a percentage: where Net Profit = (Expected Returns - Total Costs). This derivation provides a clear benchmark for viability, with positive ROI indicating financial justification; for instance, software projects often target at least 20-30% ROI to account for risks and opportunity costs.[66][67]Design and Architecture
The design phase in software development follows requirements analysis and focuses on creating a blueprint for the system that translates analyzed needs into structured plans. This phase encompasses high-level design (HLD), which outlines the overall system architecture and component interactions, and low-level design (LLD), which details the internal workings of individual modules.[68] HLD provides a strategic overview, defining major subsystems, data flows, and interfaces without delving into implementation specifics, while LLD specifies algorithms, data structures, and module logic to guide coding.[69] High-level design establishes the foundational structure, such as through architectural patterns like the Model-View-Controller (MVC), originally developed by Trygve Reenskaug at Xerox PARC in 1979 to separate user interface concerns from data management and control logic. In MVC, the Model represents data and business rules, the View handles presentation, and the Controller manages input and updates, promoting separation of concerns for easier maintenance.[70] This phase ensures the system is modular, where components are divided into independent units that can be developed, tested, and scaled separately, enhancing flexibility and reducing complexity.[71] Low-level design refines HLD outputs by specifying detailed module behaviors, including algorithms for processing and interactions between subcomponents. Scalability is a core consideration here, achieved by designing for horizontal or vertical growth, such as through load balancing or distributed components, to handle increasing demands without redesign.[72] Unified Modeling Language (UML) diagrams support both phases; class diagrams illustrate static relationships between objects, showing attributes, methods, and inheritance, while sequence diagrams depict dynamic interactions via message flows over time.[73][74] Design principles like SOLID, introduced by Robert C. Martin in 2000, guide robust architecture by emphasizing maintainability and extensibility. The Single Responsibility Principle mandates that a class should have only one reason to change, avoiding multifaceted code. The Open-Closed Principle requires entities to be open for extension but closed for modification, using abstraction to add functionality without altering existing code. The Liskov Substitution Principle ensures subclasses can replace base classes without breaking behavior, preserving polymorphism. The Interface Segregation Principle advocates small, specific interfaces over large ones to prevent unnecessary dependencies. Finally, the Dependency Inversion Principle inverts control by depending on abstractions rather than concretions, facilitating loose coupling.[75] Key artifacts produced include architecture diagrams visualizing component hierarchies and flows, pseudocode outlining algorithmic logic in a high-level, language-agnostic form, and database schemas defining tables, relationships, and constraints for data persistence.[76][77] Security by design integrates protections from the outset, applying principles like least privilege and defense in depth to minimize vulnerabilities in architecture, such as through secure data flows and access controls.[78] Performance optimization involves selecting efficient patterns, like caching strategies or optimized data structures, to meet non-functional requirements without premature low-level tuning.[79]Implementation and Coding
Implementation and coding, the core phase of translating software design specifications into executable source code, involves developers constructing the actual program based on architectural blueprints and requirements outlined in prior stages. This process requires adherence to design artifacts, such as class diagrams and pseudocode, to ensure the resulting code aligns with the intended system structure and functionality. Developers typically select appropriate programming languages suited to the project's needs, such as Python for its readability in data-driven applications or Java for robust enterprise systems requiring object-oriented paradigms. The focus is on producing clean, maintainable code that implements features incrementally, often building modules or components in sequence to form a cohesive application. Key processes in this phase include writing source code, refactoring for improved structure, and collaborative techniques like pair programming. Writing source code entails implementing algorithms, data structures, and logic flows defined in the design, using syntax and constructs specific to the chosen language to create functional units. Refactoring involves restructuring existing code without altering its external behavior, aiming to enhance readability, reduce redundancy, and eliminate code smells, as detailed in Martin Fowler's seminal work on the subject. Pair programming, where two developers collaborate at one workstation—one driving the code entry while the other reviews and navigates—has been shown to improve code quality and knowledge sharing, particularly in agile environments, according to early empirical studies integrating it into development processes. Best practices emphasize disciplined coding to foster reliability and collaboration. Adhering to coding standards, such as PEP 8 for Python, which specifies conventions for indentation, naming, and documentation to promote consistent and readable code, is essential for team-based development. Code reviews, where peers inspect changes for errors, adherence to standards, and design fidelity, are a cornerstone practice that catches issues early and disseminates expertise across teams, though they present challenges in balancing thoroughness with efficiency. Integrating libraries and APIs accelerates development by leveraging pre-built functionalities; for instance, developers incorporate external modules via package managers to handle tasks like data serialization or network communication, ensuring compatibility through version pinning and interface contracts to avoid integration pitfalls. Managing challenges in implementation is critical, particularly in scaling to large projects. Complexity in large codebases arises from intricate interdependencies and growing scale, making it difficult to maintain overview and introduce changes without unintended side effects, as highlighted in analyses of embedded systems development. Handling dependencies—such as external libraries, shared modules, or cross-team artifacts—poses risks like version conflicts or propagation of errors, requiring strategies like modular design and dependency injection to isolate components and facilitate updates. Despite these hurdles, effective implementation relies on iterative refinement to keep codebases navigable. One common metric for gauging productivity during coding is lines of code (LOC), which quantifies the volume of written code as a proxy for output, but it has significant limitations. LOC fails to account for code quality, complexity, or the efficiency of solutions, often incentivizing verbose implementations over optimal ones, and varies widely across languages and paradigms. Statistical studies confirm that while LOC correlates loosely with effort in homogeneous projects, it poorly predicts overall productivity or defect rates, underscoring the need for multifaceted metrics like function points or cyclomatic complexity instead.Testing and Quality Assurance
Testing and quality assurance (QA) in software development encompasses systematic processes to verify that software meets specified requirements, functions correctly, and is reliable under various conditions. These activities occur after implementation to identify defects, ensure performance, and validate overall quality before deployment. QA integrates both manual and automated methods to detect issues early, reducing costs associated with late-stage fixes, as defects found during testing can be up to 100 times less expensive to resolve than those discovered in production. Software testing is categorized by levels and approaches to cover different aspects of verification. Unit testing focuses on individual components or modules in isolation, ensuring each functions as intended without external dependencies. Integration testing examines interactions between these units to detect interface defects. System testing evaluates the complete, integrated software against functional and non-functional requirements in an environment simulating production. Acceptance testing, often the final phase, confirms the software meets user needs and business objectives, typically involving stakeholders. These levels build progressively to provide comprehensive validation. Testing approaches are classified as black-box or white-box based on visibility into the internal structure. Black-box testing treats the software as opaque, assessing inputs and outputs against specifications without examining code, which is useful for end-user scenarios. White-box testing, conversely, requires knowledge of the internal logic to design tests that exercise specific paths, branches, and conditions, enhancing thoroughness in code verification. Hybrid approaches combine elements of both for balanced coverage. Key techniques include test-driven development (TDD), where developers write automated tests before implementing functionality, promoting modular design and immediate feedback. TDD, pioneered by Kent Beck as part of Extreme Programming, follows a cycle of writing a failing test, implementing minimal code to pass it, and refactoring while ensuring tests remain green. Automated testing frameworks like JUnit facilitate this by providing tools for writing, running, and asserting test outcomes in Java environments. Bug tracking systems, such as those integrated into tools like Jira or Bugzilla, enable systematic logging, prioritization, assignment, and resolution of defects, improving traceability and team collaboration.[80][81][82] Quality metrics quantify testing effectiveness and guide improvements. Defect density measures the number of defects per thousand lines of code (KLOC), calculated as defects found divided by system size in KLOC, serving as an indicator of software maturity; lower values, such as below 1 defect per KLOC, suggest high quality in mature projects. Code coverage assesses the proportion of code exercised by tests, with a common goal of 80% or higher to minimize untested risks. It is computed using the formula: This line coverage metric helps identify gaps but should complement other measures like branch coverage.[83][84] QA processes ensure ongoing reliability through regression testing, which re-executes prior tests after changes to confirm no new defects are introduced, often automated to handle frequent updates in iterative development. Performance benchmarking establishes baselines for metrics like response time and throughput, comparing subsequent versions to detect degradations; tools simulate loads to measure against standards, such as achieving sub-200ms latency under peak conditions. These processes, applied to code from the implementation phase, form a critical feedback loop in the software development life cycle.Deployment and Maintenance
Deployment in software development refers to the process of making a software application or system available for use by end-users, typically following successful testing and quality assurance phases. This stage involves transitioning the software from a controlled development environment to production, ensuring minimal disruption and high availability. Effective deployment requires careful planning to mitigate risks such as downtime or compatibility issues, often leveraging strategies tailored to the software's scale and user base. Common deployment strategies include big bang deployment, where the entire system is released simultaneously to all users, offering simplicity but higher risk of widespread failure if issues arise. Phased rollout, in contrast, introduces the software incrementally to subsets of users, allowing for monitoring and adjustments before full release, which reduces overall risk in large-scale applications. Blue-green deployment maintains two identical production environments—one active (blue) and one idle (green)—enabling seamless switching between them to deploy updates without interrupting service, a technique popularized in cloud-native architectures. Containerization has revolutionized deployment since the introduction of Docker in 2013, which packages applications with their dependencies into portable containers, facilitating consistent execution across diverse environments and simplifying scaling in platforms like Kubernetes. Maintenance encompasses the ongoing activities to ensure the software remains functional, secure, and aligned with evolving needs after deployment. It is categorized into four primary types: corrective maintenance, which addresses bugs and errors reported post-release to restore functionality; adaptive maintenance, involving modifications to accommodate changes in the operating environment, such as updates to hardware or regulatory compliance; perfective maintenance, focused on enhancing features or performance based on user feedback to improve usability; and preventive maintenance, which includes refactoring code to avert future issues and enhance maintainability without altering external behavior. These types collectively account for a significant portion of the software lifecycle cost, with studies indicating that maintenance can consume up to 60-80% of total development expenses in long-lived systems. Key processes in deployment and maintenance include release management, which coordinates versioning, scheduling, and documentation to ensure controlled updates, often using tools like Git for branching and tagging. User training programs are essential to familiarize end-users with new features or interfaces, minimizing adoption barriers through tutorials, documentation, or hands-on sessions. Monitoring tools, such as log aggregation systems (e.g., ELK Stack) and alerting mechanisms (e.g., Prometheus), provide real-time insights into system performance, enabling proactive issue detection via metrics on uptime, error rates, and resource usage. As software reaches the end of its lifecycle, retirement planning becomes critical to phase out the system responsibly. This involves data migration to successor systems or archives to preserve historical records, ensuring compliance with data protection regulations like GDPR, and communicating decommissioning to stakeholders to avoid service gaps. Proper retirement prevents legacy system vulnerabilities and reallocates resources, with frameworks like the Software End-of-Life (EOL) guidelines from vendors such as Microsoft outlining timelines for support cessation and migration support.Methodologies
Waterfall Model
The Waterfall Model is a traditional methodology for software development that structures the process into sequential phases, where each stage is typically completed before proceeding to the next, providing a disciplined progression. Originating from Winston W. Royce's 1970 paper "Managing the Development of Large Software Systems," the model outlines a flow: system requirements, software requirements, preliminary design (analysis), detailed program design, coding and debugging, integration and testing, and finally operations and maintenance.[85] Although commonly depicted as strictly linear without overlap or feedback, Royce's original illustration included feedback loops from later phases back to earlier ones, allowing for iterations and refinements based on issues identified during development.[85] Royce emphasized thorough documentation at each review point to validate deliverables and mitigate risks.[85] This phased approach provides a clear structure that facilitates project management through well-defined milestones and responsibilities, making it straightforward to track progress and allocate resources.[86] Documentation is comprehensive and produced incrementally, serving as a reliable reference for future maintenance or regulatory compliance.[86] It is particularly suitable for small-scale projects with stable, well-understood requirements upfront, where changes are minimal and predictability is prioritized over adaptability.[87] However, the model's rigidity makes it inflexible to evolving requirements, as alterations in early phases necessitate restarting subsequent stages, often leading to delays and increased expenses.[87] Testing occurs late, after implementation, which can result in discovering major issues only during verification, amplifying rework costs exponentially—according to Barry Boehm's analysis, the relative cost to correct a defect discovered in maintenance can be 100 times higher than if identified during requirements.[88] No functional software is available until near the end, heightening project risks if initial assumptions prove incorrect.[87] The Waterfall Model finds application in regulated industries requiring strict documentation and verifiable processes, such as aerospace and defense, where safety-critical systems demand fixed specifications and compliance with standards like DO-178C for avionics software.[89]| Phase | Description | Gate/Review |
|---|---|---|
| System Requirements | Define overall system needs and objectives. | Approval of high-level specs. |
| Software Requirements | Specify detailed software functions and constraints. | Sign-off on requirements document. |
| Preliminary Design (Analysis) | Develop high-level architecture and feasibility. | Design review for viability. |
| Detailed Program Design | Create detailed blueprints, including modules and interfaces. | Validation of design completeness. |
| Coding and Debugging | Implement code based on designs. | Unit testing and code walkthroughs. |
| Integration and Testing | Assemble components and verify against requirements. | System testing acceptance. |
| Operations and Maintenance | Deploy, operate, and maintain the software. | Final delivery and handover. |