The Software Engineering Life Cycle

It takes far more than coding to create software that meets the user’s needs and continues to do so over time. Software is created and maintained through a structured process called the software development life cycle. There are many variations. The waterfall life cycle is sometimes called the classic model; other models borrow from it and improve upon it. The waterfall method can be seen as a response to unplanned “code and fix” software development – and many other models can be seen as responses to waterfall.

The Waterfall Life Cycle Model

The classic waterfall model has discrete stages, each one flowing into the next. There are six stages: requirements analysis, design, implementation, validation, installation, and maintenance.

In the initial stage, software developers determine the functional and nonfunctional requirements. This is sometimes called requirements extraction because software engineers may have to dig to uncover the true requirements. At the onset, the clients may have only a vague idea of what they want the software to do, and they may not understand the needs of the end user. There may also be contradictions. The requirements process typically includes putting together a set of use cases.

Software design includes both architecture (putting together the big picture) and writing algorithms. The complexity of the design process depends on a number of factors, including whether there is an interface or the entire program is automated.

Implementation refers to coding. At this stage, developers have a well-formulated plan; it has to be put into a language the computer can understand. The next stage is deployment. This involves not only releasing the software for use, but training users and offering technical support.

Iterative and Incremental Life Cycle Models

In spiral and iterative life cycle models, development passes through the same stages, but does so multiple times as the product is refined. Each turn, or itineration, wraps up with planning for the next one. (Some iterations don’t actually involve product releases, but they will typically pass through at least the first four phases of the life cycle.)

The development process may stretch across quite a few years, though the product may become available for use early on. The most basic functions may in fact, be available sooner than they would if the classic waterfall model were utilized. New functionality is added with subsequent releases.

There are a number of variations on the iterative model. The word “spiral” is typically used for projects that have long iterations. Spiral models are often used for high-budget software. Risk analysis is a key component and is built into each turn around the spiral.

Incremental models also involve traveling through the development stages more than once. A key difference is that the project is broken into chunks at the onset, and each section is carried through the developmental process before being integrated into the whole. Projects out in the real world may involve both an incremental process and an iterative one.

Agile models have very short iterations – sometimes as short as a week. They can be effective from a business standpoint because clients have frequent opportunities to see an actual product (as opposed to a stack of paperwork). Some agile methodologies are used only for particular parts of the process while others provide a framework that can be used from start to finish. Seattle University, which has earned quite a reputation in the software engineering field, uses an agile model for senior and graduate projects. The model works well in many software engineering contexts, the chair explains; it is particularly useful for teaching as short iterations mean lots of opportunities for feedback. Still, no one model is effective for all situations – that’s one reason students learn to function effectively within multiple frameworks.