Agile Software Development and traditional software engineering

First, the traditional software engineering

Since the 60 's, people have come to realize the fact that there is a "software crisis" in which software developers are troubled by issues such as the following:

• Software production does not meet the growing need
• Software development costs and development progress estimates are often inaccurate
• Insufficient information exchange between software developers and users, low customer satisfaction with completed software
• Software is expensive, the proportion of software costs in the entire computer system has risen sharply, and software has become the most expensive project in many computer systems.
• Software quality is difficult to guarantee
• Software maintainability is poor, error in the program is difficult to correct, adaptability or perfect maintenance is extremely difficult

One of the most important reasons for the crisis is that software development and maintenance is an engineering task, but the way the software personnel take it is not engineering. In order to overcome the software crisis, people began to consider the use of engineering methods and engineering approaches to develop and maintain software. We take the waterfall model and the spiral model two models as an example to discuss.

1. Waterfall model

In the traditional software engineering model, the Waterfall model is 1970 W. The earliest software development model proposed by Royce was a classic predictive software development model, which was the only widely used software development model until the early 80. The model strictly stipulates the tasks of each stage, and the previous phase of the task output as the next stage of work input. Its life cycle is divided into:

• Feasibility studies and Planning (planning): Feasibility analysis of software, estimation of development costs and time, etc.
• Demand analysis: To understand the needs of the user, to solve the "What to do" problem
• Design: Divided into summary design and detailed design. Analyze the problems that need to be solved, propose solutions and solve the problem of "how to Do"
• Implementation (coding): According to the design results, using a programming language to implement
• Test: After the coding is over, test with a large amount of data to find the hidden errors
• Use and maintenance: Once the software is delivered to the user, it is still possible to make errors during operation and the user's requirements may change, so the software needs to be modified

2. Spiral Model

Helical models (Spiral model) use a cyclical approach to system development. The model is a rapid prototyping method, centered on evolutionary development and using the waterfall model method at each project stage. Each cycle of this model includes the requirements definition, risk analysis, engineering implementation, and review 4 phases, which are iterated by these 4 phases. Software development process every iteration, software development and a level of progress. The Spiral model emphasizes risk analysis, which allows developers and users to understand the risks of each evolution layer and then respond accordingly, making them particularly suitable for large, complex and risky systems.

The spiral model has several iterations along the Helix, and the four quadrants in the diagram represent the following activities:

• Make a plan: Determine the software objectives, select the implementation plan, and clarify the constraints of project development;
• Risk analysis: Analyze and evaluate selected scenarios and consider how to identify and eliminate risks;
• Implementation of the project: the implementation of software development and validation;
• Customer Evaluation: Evaluate the development work, propose the amendment proposal, make the next plan.

The Helix model, driven by risk, emphasizes the option and constraints to support software reuse, and helps to integrate software quality into product development as a special goal.

Second, agile development

Although traditional software engineering solves the crisis and makes the software development become structured and systematic, the follow-up of software development will still produce many problems, and agile development is born.

In 2001, the Agile Alliance signed the "Manifesto for Agile Software Development", which states:

• Individuals and mutual assistance above processes and tools
• Working software is more than detailed documentation
• Customer cooperation is higher than contract negotiation
• Response change is higher than following plan

Agile development emphasizes effective response to change, rather than conforming to the plan, which is the main difference between agile development and traditional software engineering. In addition, agile development will be a member of the development team to eliminate the gap, better and faster communication and cooperation, in order to complete the project, so agile development more adaptable to customer demand changes.

Agile alliances define the 12 principles of agile development for people who want to reach Agile:

• Our top priority is to make our customers happy by delivering valuable software early and consistently.
• Even in the late stages of development, it is welcome to change demand. Agile processes leverage change to create competitive advantage for customers.
• The constancy of delivery can work on the software, the delivery interval can be from a few thoughtful months, the shorter the time interval the better.
• Throughout the development of the project, business people and developers must work together every day.
• Build projects around motivated individuals. Provide them with the environment and support they need, and trust them to get the job done
• Within the team, the most effective and efficient way to deliver information is through face-to-head conversations.
• Working software is the primary measure of progress.
• Agile processes promote sustainable development speed. Responsible people, developers and users should be able to maintain a long-term, constant development speed
• Constant attention to excellent skills and good design will enhance agility.
• Simple----The art----to maximize unfinished work is fundamental.
• The best architectures, requirements, and designs come from a self-organizing team.
• Every once in a while, the team will reflect on how to work more effectively, and then adjust their behavior accordingly.

We take the example of extreme programming and scrum as a discussion.

1, Extreme Programming (XP)

Extreme programming is one of the most widely used methods in agile software development, is a lightweight, dexterous software development method, is a kind of near-spiral development method, it decomposes the complex development process into a relatively simple small period, through positive communication, feedback and a series of other methods, Developers and customers can be very aware of the development progress, changes, problems to be solved and potential difficulties, etc., and adjust the development process according to the actual situation in a timely manner.

The process of extreme programming is divided into 4 steps:

• Planning: Listen to User stories, determine the input and output and functional characteristics required by the software, and determine its priority.
• Design: Strictly abide by the KIS (keep it simple) principle, using a brief description.
• Coding: The team developed a series of unit tests to detect this release, including all stories, and once the code is complete, test it to provide feedback to the developer.
• Testing: Organizing individual tests into a common test set, integrating and confirming tests on a daily basis, and finally conducting acceptance tests.

2. Scrum

Scrum is one of the most widely used agile development models today.

The Scrum development process is a sprint-incremental iterative development process. At the beginning of the sprint, the team selects the appropriate project from the product order that has been prioritized, clarifies the requirements with the PO and produces the same prioritized sprint orders, and is guaranteed to be done before the end of the sprint. Each working day team collects reports about each other's task processes and the amount of remaining tasks. At the end of the sprint, the team shows the final project results and collects feedback from outside the team, using the following Sprint's self-promotion.

Three or two contrast

Traditional software engineering arises from the crisis, it makes the development of software structure engineering, at first, it does bring great benefits to software development, but with the increase of time, the characteristics of traditional software engineering rules have brought great trouble to software development:

• The division of each phase is completely fixed, and a large number of documents are generated between phases, greatly increasing the workload.
• Because the development model is linear, users can only see the development results at the end of the process, thereby increasing the risk of development.
• Track individual project stages with too many mandatory finish dates and milestones.
• Not adapt to changes in user needs. This is also the core of the waterfall model shortcomings.

Thus, in order to avoid the drawbacks of traditional software engineering, software development models such as spiral models are also developed to reduce development risk and enhance flexibility.

• Take a look at the benefits of agile development compared to traditional software development
• Customers become part of the development team;
• Ability to frequently submit intermediate incremental products that can work;
• Can constantly change the needs of the project to adapt to changes in user needs;
• No need to develop detailed unrealistic plans and lengthy documentation to make the team more flexible
• Emphasis on software that can be applied, short development cycle

Agile development and traditional software engineering in the cost of the difference is very large, the traditional development of the cost of change costs of the evolution of a non-linear growth, the increase in time increases the rate is also faster, and agile development and different, the cost of change in the earlier period of time increases, the rate of growth slows, But a time node will also grow faster, but much less than traditional software engineering.

Agile development can bring many benefits but it does not apply to all projects, all products, all people and all situations, nor is it completely antagonistic to traditional software engineering practices. Agile Development also has its drawbacks:

• The requirements are variable. Too much emphasis on customer needs can lead to a plan to disrupt the entire software project in order to achieve a requirement.
• Conflicting customer needs. Excessive customer demand may lead to contradiction in demand.
• Informal representation of demand. Many of the requirements are verbal and informal, and cannot be found in time for missing or inconsistent errors
• Lack of formal design. The development of complex systems does not guarantee the quality and maintainability of the software architecture.

In summary, agile development can indeed be more appropriate to respond to user needs than traditional software engineering, but is not a soft-ware development, and traditional software development because of its structured and formalized design is still able to have a place.

Resources

1, "Software Engineering: Practitioners of Research Methods (seventh edition)" Roger S.pressman

2. The improvement and application of Scrum Agile software development method practice

Chen Guodong, Luo province Yin Computer Technology and Development 21st Volume 12th Issue December 2011

3, Baidu Encyclopedia waterfall model

Http://baike.baidu.com/link?url= kfptsc14xgqbv-hojxqbcp6nzel0njgl8wamdur4e0fi27tdm0cnws96azfaodj9n3khku51afscvi5j3rifrqhvcnezruxtuklacn3q-blft59btslz2jb4v Upk-8zk

4, Baidu Encyclopedia spiral Model

Http://baike.baidu.com/link?url= Fo9hnjpfvbhgpxqgsawygcxpk97pqrmhxith4e1sxeyqlq5fisf-6qpewoaxvwmfbcedtxrybwlhm0yjm0nvxvibwmgx86uzdajm6vnwnx4i0uhikzfs1a1sm Ohz4_dv

Agile Software Development and traditional software engineering