In the beginning of digital computing in the early 1940s, operation instructions were physically wired into them. However, the inflexibility of this design made it a short-lived one. Engineers invented 'stored program architecture' to combat this inflexibility, achieved by the separation of software from hardware. This abstraction is what makes the complexity of modern computing possible.
Software development encompasses the entire process of creating a software product and getting it working for and beyond release. However, the term 'software development' more often refers to the actual programming wherein an individual or team writes and maintains a stretch of sourcecode. Other activities vital to software development include research, new development, prototyping and deploying updates. In general, software is developed for one (or more) of 3 reasons:
- personal use
- to meet the perceived needs of a group of potential users
- to create a piece requested specifically by a client
- as a subsection of this, embedded software development is the development of software to be integrated into another product for control or reporting problems
There are a range of ways to go about developing software, and much of it depends greatly on resources available and personal work style and tastes. However, all methods include some form of what is known as the software development lifecycle - namely, design, implementation, testing, deployment and debugging/maintenance. Problem analysis, market research and gathering resources are all equally necessary steps but they tend to occur before the actual development begins, as preparation and are therefore not really included in the lifecycle in their own right, but occasionally as a subsection of the design step.
The lifecycle is not standardized as such; the above separates pre-design steps out and lumps deployment and maintenance under 'evolution'. [ Credit: Cliffydcw ]
Below are some of the common approaches to software development:
- waterfall development - highly structured approach based on engineering practices wherein steps are clearly laid out and completed in strict order, involving the big design up front idea. Progress is tracked carefully through many forms. This method is not terribly flexible and is prone to running over money and time budgets.
- incremental development - combines a linear and iterative approach for a series of mini-waterfalls that are reassessed as the project is assembled tiny prototype by tiny prototype to achieve a final prototype of the entire system
- rapid application development - an approach specializing in speed, RAD prioritizes requirements to release early betas and the like for user input before even a first full release in order to spend their focus tailoring the software to the desired end users' biggest demands first.
- slow programming - an alternative to RAD which prioritizes as bug-free a first release as possible, meaning each part undergoes significant in-house testing and debugging before being exposed to the public.