Today we are living in the heroic age of extreme development. The demand for advanced software made the software engineers explore new methods for Software Development. However, new techniques follow the same old methodologies but in a modernized way. Have you ever wondered how any software is created and which procedures the developers follow to build new software?

Software development is becoming vital to nearly every organization. The software development practice has been advanced from its beginning about a half-century ago.

History of Software Development

Software development history
The development of an information system began as early as 1940 up to 1960. The rise of the software crisis leads to the development of organized and systematic software engineering approaches. Certainly, the software industry is very dynamic and requires constant updating. Therefore, numerous methodologies of Software Development have been proposed for the efficiency and improvement of the software. Currently, the field of software engineering uses life cycle models for software development. These models include the Waterfall model, Agile model etc. Among all the life cycle models, Agile is the most popular and reliable one.

The Idea of Project Management

In 1910, Henry Gantt and Frederick Taylor proposed the idea of project management by inventing the diagram of project management. Moreover, they defined the processes to perform repetitive tasks. These helped in the improvement of industrial productivity.

Furthermore, in 1916 Henri Fayol introduced the concepts e.g. division of work, the unity of command, centralization of discussion.

Team Work

In the period of 1927-1932, Elton Mayo carried the Hawthorne experiment. The results of the experiment concluded that the motivational work of the team helps to increase productivity.

The Waterfall Approach

The time of the 1950s basically depended on code and fix methodologies. However, in 1953, the idea of software was introduced which was not taken seriously at that time. In 1956, Herbert D. Bennington gave the first formal description of the Waterfall model. Bell and Thayer, in 1976, used the earliest term of Waterfall. In 1985, the US Department of Defense standardized the Waterfall methodology. This approach was defined as the standard approach for Software Development. The Waterfall model comprises of 6 stages: Preliminary design, Detailed Design, Development, Unit testing, Integration, and Testing.

The Spiral Model and Scrum

In 1986, Barry Boehm described the process of software development in the form of Spiral Model. The spiral processes use iterative development concepts to reduce the risks. The term Scrum was also introduced in 1986 by Takeuchi and Nonaka. Scrum was defined as an approach to organizational knowledge creation. This method is a good tactic for bringing innovation in a constant and beneficial way. Furthermore, in 1990, Ken Schwaber referred to Scrum as Advanced Development Method. Meanwhile, Jeff Sutherland developed a related method, referring to it with the single word Scrum. Schwaber and Sutherland described the Scrum methodology in 1995.

Iterative & Incremental Software Processes

The period of 1996-1998 gave rise to iterative and incremental software processes. This process became standard for the industry because it is focused on structural design.

Agile Revolution

The age of 1999 is the time of the Agile revolution. In 2001, Agile manifesto was published.

DevOps Approach

DevOps was introduced in 2009 which is now the most reliable than other methodologies.

Software Development Methodologies

Software development methodology is a framework used to plan, structure, and process the development of an information system. The following methodologies are used in the field of software engineering for the development of software.

  • Software Development Life Cycle
  • Crystal Methods
  • Dynamic Systems Development Model
  • Extreme Programming
  • Feature Driven Development
  • Joint Application Development
  • Rapid Application Development
  • Lean Development
  • Rational Unified Process

Software Development Life Cycle

Software development life cycle is a theoretical approach to project management. It is a series of stages which provides a common understanding of the process of software development. Moreover, the process of SDLC has different important stages each perform a different function. Software development life cycle improves the development process and quality of the software.

SDLC comprises of the following stages

  • Requirement analysis
  • Design
  • Implementation
  • Testing
  • Launch and Maintenance

For the development of software, SDLC models are used including:

  • Waterfall Model
  • V-Shaped Model
  • Evolutionary Prototype Model
  • Spiral Model
  • Iterative & Incremental Method
  • Agile Development

Waterfall Model

It is a traditional approach to project management. Waterfall model is a linear sequential flow. In the Waterfall model, the movement flows in a linear manner from a high level to low, just like Waterfall flow. As discussed earlier, there are several stages of a software application in the Waterfall model. The sequential downward flow completes and starts different stages one after another. Also, the stages never overlap as the output of one stage serves as the input of the next one. It is the earliest approach which is the root of software development.

The Waterfall model is advantageous for some projects although it also has some disadvantages.

The advantages of the Waterfall model are as follows

  • Easy to explain to the client
  • Structural approach
  • Well defined stages
  • Schedule the project

The disadvantages of the Waterfall model are the following

  • Difficult to return to the previous phase.
  • Less flexible
  • Does not allow alteration of the previous stage
  • Costly and consumes more time

Thus, the Waterfall model is ideal for the projects which do not focus on changing the requirements.

V-Shaped Model

The V-Shaped model is an extension of the Waterfall approach. Like Waterfall model, the V-shaped model does not flow in a linear way, but the process runs in V shape. The steps of process bend upward after implementation and coding phase. The early test planning is the major difference between Waterfall and V-shaped model.

The advantages of V-shaped model are as follows:

  • Simple and easy to use
  • Specific deliverable at each stage
  • Higher chances of success as compared to the Waterfall model

The following are the disadvantages of V-shaped model:

  • Not flexible
  • Difficult and expensive adjusting scope
  • No early prototypes are made before the implementation stage
  • Does not offer a clear solution for problems

Therefore, projects having clearly defined and known software requirements use this model. Another condition which makes this model applicable is that the software development technologies and tools should be well-known.

Evolutionary Prototype Model

The prototype model refers to creating prototypes for software applications. This model creates dummy prototypes by developing incomplete versions of the software program. Certainly, creating prototypes is a usual activity in software development. Thus, this activity visualizes the components of the software. It also limits the gap of creating problems which reduce iterations.

Prototyping is of following types:

Throwaway Prototyping:

These are eventually discarded and does not become part of final software.
Evolutionary Prototyping:
These evolve into the final system. Iterative incorporation of user feedback helps this process.

Incremental Prototyping:

The final product is made after the creation of several separate prototypes. These separate prototypes merge in the end to make an overall design.

Extreme Prototyping:

It breaks down web development into three phases. The first phase is an HTML based static prototype. In the second phase, simulated services layer programs the screens and make it fully functional. The third phase is of implementation.

The advantages of this model are as follows:

  • Time and cost are reduced
  • Appreciates user involvement

The disadvantages are as follows:

  • Insufficient analysis
  • Excessive prototype development time

In conclusion, the prototyping model is good for the projects which involve user’s participation.

Spiral Model:

The Spiral model is a combination of Prototyping and Waterfall model. This model is ideal for large complicated projects. Moreover, it follows the same stages as the Waterfall model. However, it is parted by planning, risk assessment, and the prototype creation and simulations.

Advantages of the spiral model include realistic estimation and risk management. Whereas, the disadvantages of this model are it requires special skills to evaluate the risks. Moreover, it is highly customized which limits the re-usability.

Hence, the projects which have large applications and systems use the spiral model.

Iterative and Incremental Model:

This model overcomes the limitations of the Waterfall model. It starts with initial planning and ends with deployment. All the stages have cyclic interactions. Furthermore, this model has repetitive cycles which makes the development of each cycle easier. Also, this model consists of a mini Waterfall or v-shaped models.

Advantages of the iterative model are that it can detect project issue at early stages. Also, it focuses more on customer value and can accommodate some changes requests. However, there are some disadvantages also including heavy documentation. It also requires more customer involvement than linear approaches.

Therefore, the projects having separate components or segments use this model as a shrink-wrap application.

Agile Model:

In the Agile model, the requirements and solutions developed through collaboration between cross-functional teams. The Agile model is based on the iterative and incremental approach. Moreover, there are several Agile methodologies including Crystal Method, Dynamic System Development Model, and Scrum etc. However, most Agile methods minimize the risk by developing software in iterations. Hence each iteration is like a small-scale software design of its own. It also includes all the tasks essential to deliver the mini-increment of new functionality. For instance, planning, requirements analysis, design, coding, testing, and documentation. Whereas iteration may not add enough functionality to license delivering the product.  Thus, an Agile software project aims to be capable of distributing new software at the end of every iteration. At the end of each iteration, the team re-examines project priorities.

Any type of project can use Agile. The advantages of Agile include customer involvement, less development time, and high-quality end results etc. However, the disadvantages of Agile are last stage documentation, scalability, reduced usability etc.

Agile methods also highlight working software as the primary measure of progress. Moreover, Agile methods produce very little written documentation relative to other methods.

Crystal Method:

The crystal methods approach was created by Alistair Cock burn. He believed that people interaction, skills, talents, and communication have a first-order effect on performance. The process of development is also important but has secondary value. According to Cock burn’s philosophy, each team comprises of a different set of skills and talents. Therefore, each team should work on a significant process which utilizes its resources in a unique way.

The word crystal refers to various sides of a gemstone, each having a different face and basic core. Likewise, in the crystal methodology, the core represents values and principles whereas each face represents a specific set of elements such as tools, techniques, roles, and standards etc. Cock burn’s work also differentiated techniques, methodologies, and policies. According to which, a technique is a skill area, a methodology is a set of components, and policies dictate the organization.

Dynamic Systems Development Model:

The Dynamic System Development Model is the evolution of Rapid Application Development practices. It was developed in the mid-1990s. DSDM is based on nine principles which are as following:

  • Active user involvement
  • An empowered team which encourages the authority to make decisions.
  • Focus on frequent product delivery
  • Use of suitability for business purpose as a vital standard on acceptance the deliverable.
  • Iterative and incremental development approach to ensure convergence on an accurate business solution.
  • Reversible changes during the developmental process.
  • Requirements baselines at high-level
  • Integrated testing throughout the life cycle
  • Cooperation and collaboration with all stakeholders.

DSDM boasts the best-aided training and documentation of any Agile software development technique. The phenomenon behind this methodology is that creating a perfect thing in the first attempt is somehow impossible. Therefore, software developmental models serve as an experimental bridge between the project and developed software.

Extreme Programming (XP) Methodology:

The extreme programming methodology creates the software within very unstable conditions. XP allows flexibility in the modeling process. Its main goal is to decrease the cost of change in the requirements of the software. As observed in the traditional development methodologies, the requirements of the project are stable and fixed e.g. Waterfall model. This means that the changing requirements can affect the project by increasing the cost of it.

Extreme programming comprises XP Practices as follows:

Fine Scale Feedback

  • The test-driven development
  • Planning the game
  • Whole team
  • The pair-programming

Continuous Process Instead of Batch

  • Continuous Integration
  • Development of Design
  • Minor Releases

Shared Understanding

  • Simple design
  • System metaphor
  • Collective code ownership
  • Coding standards

Programmer Welfare

  • Supportable pace

There are a few more practices additional to primary practices known as core practices.

  • The interaction between the developer and the client should be good.
  • Take learning to an extreme level.
  • Simple code is more likely to work
  • Code reviews should be good.
  • The testing code should be good.

The XP can include hundreds of developers working simultaneously.

Feature Driven Development Methodology:

Jeff De Luca and Peter Coad developed Feature Driven Development Methodology. According to Peter, the FDD have enough process to ensure the scaling and repeating requirements of the project. This approach is creative and full of innovation.

Feature driven development methodology focuses on the following points:

  • A scheme for building a system is necessary for scaling larger projects.
  • The well-defined process is ideal.
  • All the steps of the project should be logical.
  • Good processes move to the background, making the team more focus on the results.
  • The short, Iterative, and feature driven life cycles are finest.

Feature drove development methodology proceeds to address the points mentioned earlier with this simple process:

  • Development of an overall model.
  • Feature list builds up.
  • Feature plan
  • Design by feature.
  • Development by feature.

Joint Application Development Methodology:

JAD was developed in the 1970s, which is basically a user edge-design and requirements-definition methodology. Besides, it allows off-site meetings between developers, executives, and end-users to work out a system detail. Moreover, JAD appreciates the client’s participation in the development procedure of an application. This client participation is made through a series of collaborative workshops known as JAD sessions.

The focus of JAD is on business problems rather than technical issues. However, JAD is not only applicable to develop business systems but also develops software systems. It also gathers the system requirements better and reduces the time of gathering information. Thus, by this, the number of costly download requirements also changes. The more effective leadership, the more success there would be. This totally depends upon the participation of the developers, clients, and executives.

As compared to the Waterfall approach, JAD takes less time to develop software. Moreover, client satisfaction is the top priority of JAD approach. Both play a key role in the system development process. Furthermore, developers continuously ask the client’s requirements and appreciate the client’s participation during the developmental process.

Rapid Application Development Methodology:

Rapid application development approach is a popular strategy in software development. It is an Agile project management strategy. RAD is an attractive choice for developers due to its fast performance. It also maximizes the prototype development and minimizes the planning stage. In short, RAD allows project managers and stakeholders to measure the progress accurately. Moreover, it appreciates the client’s involvement to solve and change the issues during the process.

Rapid application development methodology is a deviation of JAD. It attempts to create the application more quickly. Moreover, RAD follows strategies which include fewer formal methodologies and reusing software components. The term rapid development language refers to any programming language which offers faster implementation as compared to C/C++, Pascal etc. RADs also reduce the amount of construction of a project. Thus, it produces savings. Furthermore, savings are made during the construction cycle and it shortens the development time.

The process of RAD comprises of the following four phases:

  • Requirement planning
  • User design
  • Rapid construction
  • Cutover

Requirement Planning:

This phase allows communication between developers, clients, and team members to determine the goals and expectations for the project. During this step, the team research the current problem, define the requirements of the project, and finalize the requirements.

User Design:

Once the project is planned, the developers build out the user design with the help of various prototype iterations. In this phase, the client and developers work side by side to design the project according to the client’s requirements. Thus, the client can customize the project and test each prototype of the project on each stage.

Rapid Construction:

This phase converts the prototypes and beta systems into the working model. The process of the construction of the final working process takes less time. This is because all the changes and problems are dealt with the iterative design phase. Thus, the rapid construction phase prepares the project for construction. Moreover, it also develops the program and application. As a result, coding is done and at the end unit integration and system, testing is performed.

Cutover:

The cutover phase makes the product ready for launch. It is basically an implementation phase which includes data conversion, testing, and switches to a new system.

Lean Development Methodology:

The focus of lean development approach is the creation of change tolerant software. Moreover, the goal of LD is to build software with least human effort. It also fewer development hours and investment. LD methodology represents the notion of stability.

Lead development methodology comprises of the following 12 principles:

  1. Customer satisfaction is a top priority.
  2. Provide the best value for money.
  3. Active customer participation is the key to success.
  4. Team effort is mandatory.
  5. Changing or alteration is possible.
  6. Provide domain solutions.
  7. Complete the project does not construct it.
  8. Believes on 80% solution today rather than 100% solution the next day.
  9. Minimalism is important.
  10. Needs define technology.
  11. Product growth has a direct effect on feature growth.
  12. LD functions properly only in between its limits.

Rational Unified Process Methodology:

The rational unified process is an Agile software development methodology. It splits the project lifecycle into four phases. Like Agile methodology, the main purpose of RUP is to create high-quality software. Expected budget and time frame are two parameters on which it works.

The four phases of RUP are as following:

  • Inception
  • Elaboration
  • Construction
  • Transition

Inception:

It is the very first stage which starts with the idea of the project. The development team defines whether this project is worth pursuing or not. Also, the team also decides the requirements of the project.

Elaboration:

The second stage evaluates the project’s design and the required resources. The developers consider probable applications of the software and costs associated with the development.

Construction:

The construction stage is the third stage which writes, develops, and tests the software. Thus, it completes the project.

Transition:

In the fourth stage of transition, the software is launched in the public. Also, the final adjustments or updates are made according to user feedback.

RUP development methodology provides a designed approach for companies to visualize and create software programs. Besides, it offers a specific plan for each step of the development process. It also helps prevent resources from being wasted. Moreover, it also reduces unexpected development costs.

DevOps:

The DevOps deployment methodology focuses on organizational change. Therefore, enhances the collaboration between the responsible sectors for different segments of the development life cycle. For instance, development, quality assurance, and operations.

The advantages of DevOps are that it aims to automate continuous deployment to guarantee everything happens efficiently and reliably. Consequently, companies that use DevOps have profited by considerably reducing the time to market. And refining customer satisfaction, product excellence, and employee production and efficiency.

The disadvantages of DevOps are the following:

  • Some clients don’t want constant updates to their systems.
  • Some industries have policies that require broad testing before a project can move to the operations level.
  • Different environments used in the different departments can permit unobserved issues to slip into production.
  • Some quality traits need human interaction, which slows down the delivery pipeline.

Which Methodology is Best for Software Development?

All the software development methodologies mentioned earlier are applicable in the area of software development. The requirements of the project select which methodology is best for the project. From Waterfall to Agile, each approach is selective to the project. Nowadays, the most used methodologies include Agile development methodology and DevOps deployment methodology.

As mentioned earlier, the Agile methodology has different forms including scrum, crystal, XP, and FDD. The Agile method minimizes risks such as bugs, changing requirements, and cost overruns. It also provides multiple iterations and improves the efficiency of the software by finding and fixing the defects simultaneously.

The DevOps deployment method focuses on the improvement of time to market. It also lowers the failure rate of new releases and helps in the shortening of lead time between fixes. DevOps benefits the companies because it improves customer satisfaction and enhances product quality.

In conclusion, the Agile and DevOps are most functional software development approaches today. Due to the critical requirements of modern projects these two fits accordingly.