Software Methodology

A software methodology (which is also known as software process) is a set of related development Phases that leads to the production of the software. 

Any software process must include the following four Phases:

1. Requirements Engineering(or Software specification): In this activity we define the main functionalities (functional or non-functional requirements) of the software and the constraints around them.
2. Software design and implementation: The software is to be designed and developed.
3. Software verification and validation: The software must conform to its specification and meet the customer's needs.
4. Software Maintenance (or Software evolution): The software is being modified to meet customer and market requirements changes.

In real life, they include many sub-Phases like architectural design, requirements validation,testing, …etc.

Software Development Models

A software development model is a simplified representation of a software process. Each model represents a process from a specific perspective.

“””

Some methodologies are sometimes known as software development life cycle (SDLC) methodologies, though this term could also be used more generally to refer to any methodology.

“””

Waterfall Model

The waterfall model is a sequential technique in which each fundamental action of a process is represented as a separate phase, which is then arranged in a linear order.

In the waterfall model, all Phases must be planned and scheduled before beginning work on them (plan-driven process).

“””

Plan-driven process is a process where all the Phases are planned first, and the progress is measured against the plan. While the agile process, planning is incremental and it’s easier to change the process to reflect requirement changes.

“””

The phases of the waterfall model are: Requirements, Design, Implementation, Testing, and Maintenance.

The Waterfall Model — From Software Engineering, 9th edition, Chapter 2, by Ian Sommerville

When To Use?

In general, the waterfall model should be used only when needs are well understood and unlikely to change significantly during development, as this model has a somewhat inflexible structure that makes it difficult to adapt to change while the process is in progress.

Iterative Waterfall model:

In fact, it is not practical to perfectly adhere to the traditional waterfall paradigm when developing software. In this sense, we can see the iterative waterfall model as modifying the original waterfall model to make it appropriate to practical software development initiatives.

As seen in the Iterative waterfall model, feedback pathways are provided from each phase to its preceding phase.

The feedback channels allow for the rectification of errors committed during a phase as they are discovered in a later phase.

For example, if during a testing a design error is identified, then the feedback path allows the design to be reworked and the changes to be reflected in the design documents. However, observe that there is no feedback path to the feasibility stage. This means that the feasibility study errors cannot be corrected.

Disadvantages:

• It is not desirable for complex project where requirement changes frequently
• Testing period comes quite late in the developmental process
• Clients valuable feedback cannot be included with ongoing development phase

Prototyping

A prototype is a fast version of a system or element of a system created to test the customer's needs or the viability of specific design decisions.

A prototype is therefore useful when a customer or developer is unsure of the needs, algorithms, efficiency, business rules, reaction time, and so on.

A software prototype can be used:

A prototype can aid in the elicitation and validation of system requirements during the requirements engineering process.

It enables users to experiment with the system and, as a result, refine the requirements. They may come up with new requirements and identify areas of strength and weakness in the software.

In system design, a prototype can aid in the execution of design experiments to determine the viability of a proposed design.

A database architecture, for example, may be prototyped and tested to ensure that it allows efficient data access for the most common user queries.

The process of prototype development — From Software Engineering, 9th edition, Chapter 2, by Ian Sommerville

The phases of a prototype are:

1. Establish objectives: The prototype's goals should be made clear from the outset of the project. Is it to validate system needs, show feasibility, and so on.
2. Define prototype functionality: Determine the inputs and expected outputs of a prototype. To reduce prototyping expenses and accelerate delivery, you can overlook some capabilities, such as reaction time and memory use, unless they are crucial to the prototype's goal.
3. Development of the prototype: The initial prototype is developed that includes only user interfaces.
4. Evaluate the prototype: Users identify requirements flaws after being trained to use the prototype. Both the specs and the prototype can be improved using the input. If changes are made, steps 3 and 4 may need to be repeated.

Prototyping is not a comprehensive development methodology in and of itself, but rather an approach to be utilized in conjunction with a full methodology (such as incremental, spiral, etc).

Disadvantages:

This model is costly. It has poor documentation because of continuously changing customer requirements. There may be too much variation in requirements. Customers sometimes demand the actual product to be delivered soon after seeing an early prototype.

Incremental Development

Incremental development is built on the concept of creating an initial implementation, exposing it to user feedback, then modifying it via successive versions until an acceptable solution is created.

The Incremental Development Model — From Software Engineering, 9th edition, Chapter 2, by Ian Sommerville

Each system increment represents a piece of functionality that the consumer requires. In general, the initial increments of the system should include the most vital or urgently required functionality.

This means that the client can inspect the system early in the development process to ensure that it meets the specifications.

It can be a plan-driven or agile, or both

One of the most prevalent ways is incremental development. This method can be plan-driven, agile, or both.

The system increments are identified in advance in a plan-driven method, while in an agile approach, only the early increments are identified, and the development of later increments is dependent on progress and client priorities.

It’s not a problem-free

But, it’s not problem-free …

• Some businesses' procedures have grown over time and are incompatible with informal iterative or agile methods. Procedures, for example, to ensure that the programme complies with external regulations.
• As fresh increments are introduced, the system structure degrades and becomes corrupted as regular adjustments are made. Even if effort and money are invested on reworking to improve the software, further updates become more difficult and expensive.

Spiral Model

The spiral model is risk-driven and depicts the process as a spiral rather than a series of operations.

It was created to incorporate the greatest characteristics of the waterfall and prototyping models, as well as to provide a new component: risk assessment.

The spiral model — From Software Engineering, 9th edition, Chapter 2, by Ian Sommerville

Each loop in the spiral is split into four sectors:

1. Objective setting: The objectives and risks for that phase of the project are defined.
2. Risk assessment and reduction:A complete analysis is performed for each of the identified project hazards, and efforts are made to mitigate the risk. A prototype, for example, may be created if there is a possibility that the requirements are insufficient.
3. Development and validation:Following risk assessment, a process model for the system is selected. So, if the risk in the user interface is expected, we must prototype the user interface. Use the waterfall approach if the risk is in the development process itself.
4. Planning: The project is reviewed and a decision is made whether to continue with a further loop or not.

The spiral model has had a significant impact on how people think about iteration in software processes and the introduction of the risk-driven approach to development. However, in practice, the model is rarely used.

Disadvantage:

Needs good planning and design. Needs a clear and complete definition of the whole system before it can be broken down and built incrementally. Total cost is higher than the waterfall.

Why is the spiral model also called a meta model ?

The Spiral model is called a Meta-Model because it subsumes all the other SDLC models. For example, a single loop spiral actually represents the Iterative Waterfall Model. The spiral model incorporates the stepwise approach of the Classical Waterfall Model.

Iterative Development

Iterative development seeks to create a system by constructing small pieces of all characteristics across all components.

We create a product that fits the initial scope and rapidly release it for client feedback. To develop a market and get client input, an early version with restricted capabilities is required.

Each increment delivers a slice of system functionality, progressing from requirements to deployment.

The phases of iterative development — From Software Engineering, 9th edition, Chapter 2, by Ian Sommerville

The phases of iterative development are:

1. Inception: The objective is to develop a business case for the system. We must first identify and define all external entities that will interface with the system. Then, utilize this data to evaluate the system's contribution to the business. If your contribution is insignificant, the project may be canceled.
2. Elaboration: We create a project plan, identify hazards, and gain an understanding of the issue domain and architecture framework.
3. Construction:Fills in the architecture incrementally with production-ready code derived from requirements study, design, implementation, and testing. The system's components are interdependent, and they are developed in parallel and integrated during this phase. After completing this phase, you should have fully functional software.
4. Transition:We install the system in the production environment.

All the phases will be done once, while the construction phase will be incrementally visited for each increment; for each slice of system features.

Disadvantage:

Each phase of an iteration is rigid with no overlaps. Costly system architecture or design issues may arise because not all requirements are gathered up front for the entire lifecycle.

Agile

Agility is flexibility, it is a state of dynamic, adapted to the specific circumstances.

The agile method refers to a group of software development models based on the incremental and iterative approach, in which the increments are small and typically, new releases of the system are created and made available to customers every few weeks.

The principles of agile methods — From Software Engineering, 9th edition, Chapter 3, by Ian Sommerville

Customers are involved in the development process to propose adjustments to requirements. They use informal communications rather than formal meetings with written documents to reduce documentation.

They are ideally suited for applications with frequently changing needs during the development phase.

Scrum, Crystal, Agile Modeling (AM), Extreme Programming (XP), and more agile methodologies are available.

Disadvantage:

• Poor Resource planning
• Limited Documentations
• Fragment output
• No finite end

Incremental Vs Waterfall Model

For most organizations, e-commerce, and personal systems, incremental software development outperforms waterfall development.

It is cheaper and easier to make modifications to the programme as it is being built if it is developed incrementally.

When compared to the waterfall methodology, incremental development has three significant advantages:

1. The expense of adapting to changing client needs is decreased. The amount of analysis and documentation that must be rewritten is far less than with the waterfall paradigm.
2. Customer input is easier to obtain during development than after the system has been fully designed, tested, and distributed.
3. Even if not all functionality is available, it is possible to produce useful software more quickly. Customers can use and derive benefit from the product sooner than the waterfall methodology allows.

Increment Vs Iterative Vs Agile

You might be wondering what the distinction is between incremental, iterative, and agile models.

In the incremental technique, each increment builds a whole feature of the software, whereas the iterative approach builds small sections of all features.

An agile strategy combines the incremental and iterative approaches by gradually adding features and enhancing their completeness by constructing a tiny amount of each feature one at a time.

Process Phases

Different development methods structure the four main process tasks of definition, development, validation, and evolution differently.

They are structured in sequence in the waterfall approach, but interleaved in incremental development. The manner in which these operations are carried out may vary depending on the type of software, the people involved in its development, and so on.

References:

• Software Engineering, 9th edition, Chapter 2, Ian Sommerville — A highly recommended comprehensive textbook on software engineering.
• Software Engineering, 9th edition, Chapter 3, Ian Sommerville.
• Software Process and Software Process Models (Part 2)