| Part of a series on |
| Software development |
|---|
Paradigms and models |
Standards and bodies of knowledge |
Outlines |
Software development is the process ofdesigning andimplementing asoftware solution tosatisfy auser. The process is more encompassing thanprogramming, writingcode, in that it includes conceiving the goal, evaluating feasibility, analyzingrequirements,design,testing andrelease. The process is part ofsoftware engineering which also includesorganizational management,project management,configuration management and other aspects.[1]
Software development involves many skills and job specializations includingprogramming,testing,documentation,graphic design,user support,marketing, andfundraising.
Software development involves manytools including:compiler,integrated development environment (IDE),version control,computer-aided software engineering, andword processor.
The details of the process used for a development effort varies. The process may be confined to a formal, documentedstandard, or it can be customized andemergent 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.
Each of the available methodologies are best suited to specific kinds of projects, based on various technical, organizational, project, and team considerations.[3]
Another focus in many programming methodologies is the idea of trying to catch issues such assecurity vulnerabilities andbugs as early as possible (shift-left testing) to reduce the cost of tracking and fixing them.[13]
In 2009, it was estimated that 32 percent of software projects were delivered on time and budget, and with the full functionality. An additional 44 percent were delivered, but missing at least one of these features. The remaining 24 percent were cancelled prior to release.[14]
Software development life cycle refers to the systematic process of developingapplications.[15]
The sources of ideas for software products are plentiful. These ideas can come frommarket research including thedemographics 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 bymarketing personnel for economic feasibility, fit with existing channels of distribution, possible effects on existing product lines, requiredfeatures, and fit with the company's marketing objectives. In the marketing evaluation phase, the cost and time assumptions become evaluated.[16] The feasibility analysis estimates the project'sreturn 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]
Software analysis begins with arequirements 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 oftendecompose the project into smaller objects, components that can be reused for increased cost-effectiveness, efficiency, and reliability.[19] Decomposing the project may enable amulti-threaded implementation that runs significantly faster onmultiprocessor 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 indata-flow diagrams,data dictionaries,pseudocode,state transition diagrams, and/orentity relationship diagrams.[23] If the project incorporates a piece oflegacy software that has not been modeled, this software may be modeled to help ensure it is correctly incorporated with the newer software.[24]
Design involves choices about the implementation of the software, such as whichprogramming 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 oftrial and error. Design often involves people expert in aspect such asdatabase design, screen architecture, and the performance of servers and other hardware.[19] Designers often attempt to findpatterns in the software's functionality to spin off distinct modules that can be reused withobject-oriented programming. An example of this is themodel–view–controller, an interface between agraphical user interface and thebackend.[25]
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 ofmaintenance.[27] Often, software programmers do not follow industry best practices, resulting in code that is inefficient, difficult to understand, or lackingdocumentation 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 becomes much more difficult.Code refactoring, for example adding more comments to the code, is a solution to improve the understandability of code.[30]
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), andcompatibility testing (measuring the software's performance across different operating systems or browsers).[31] When tests are written before the code, this is calledtest-driven development.[33]
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]
Software development is performed bysoftware 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 state 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 softwareprogrammers but also individuals specialized in testing, documentation writing,graphic design, user support,marketing, and fundraising. Although workers for proprietary software are paid, most contributors toopen-source software are volunteers.[38] Alternately, they may be paid by companies whosebusiness model does not involve selling the software, but something else—such as services and modifications to open source software.[39]
Computer-aided software engineering (CASE) is tools for the partialautomation of software development.[40] 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 orreverse engineer it (for example, to change theprogramming language).[41]
Documentation comes in two forms that are usually kept separate—that intended for software developers, and that made available to the end user to help them use the software.[42][43] Most developer documentation is in the form ofcode comments for each file,class, andmethod that cover theapplication programming interface (API)—how the piece of software can be accessed by another—and often implementation details.[44] This documentation is helpful for new developers to understand the project when they begin working on it.[45] In agile development, the documentation is often written at the same time as the code.[46] User documentation is more frequently written bytechnical writers.[47]
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 theproject manager.[48] Because the effort estimation is directly related to the size of the complete application, it is strongly influenced by 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.[49] 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 toweb applications ormobile applications.[50]
Anintegrated development environment (IDE) supports software development with enhanced features compared to a simpletext editor.[51] IDEs often include automatedcompiling,syntax highlighting of errors,[52] debugging assistance,[53] integration withversion control, and semi-automation of tests.[51]
Version control is a popular way of managing changes made to the software. Whenever a new version is checked in, the software saves abackup 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.[54]
Aview model is a framework that provides theviewpoints on thesystem and itsenvironment, to be used in thesoftware 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 verycomplex systems and to organize the elements of the problem around domains ofexpertise. In theengineering of physically intensive systems, viewpoints often correspond to capabilities and responsibilities within the engineering organization.[55]
Fitness functions are automated and objective tests to ensure that the new developments don't deviate from the established constraints, checks and compliance controls.[56]
Intellectual property can be an issue when developers integrateopen-source code or libraries into a proprietary product, because mostopen-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.[57]
Media related toSoftware development at Wikimedia CommonsNote: This template roughly follows the 2012ACM Computing Classification System. | |
| Hardware | |
| Computer systems organization | |
| Networks | |
| Software organization | |
| Software notations andtools | |
| Software development | |
| Theory of computation | |
| Algorithms | |
| Mathematics ofcomputing | |
| Information systems |
|
| Security | |
| Human–computer interaction | |
| Concurrency | |
| Artificial intelligence | |
| Machine learning | |
| Graphics | |
| Applied computing |
|
