What is the future way of developing the software with history as the guide?

  IT168 Technical Analysis 1975 Frederick Brooks wrote the classic of software project management-The Myth of Human Moon. In this book, his most famous view is that software projects are not always more powerful, and he believes that adding more people to software development projects will not make the project faster, but it will be a hindrance. The reason is that getting more people to work on a project can cause problems by not being fluent in communication.
 
    the waterfall Model software development method was born five years before the "Man Moon Myth" was published. This approach applies the idea of growth engineering to software. The idea is to first collect the requirements, then design, then implement, and then tested to finally get the software we need the finished product, this method under the guidance of software development is a linear process.
 
    Since then we have come a long way in terms of software development and have learned a lot about the relevant knowledge. We now know that the waterfall model is a flawed approach because it is very inflexible and does not conform to the actual situation. In the real world, software projects often have well-defined and evolving needs, and it is impossible to think of everything at once. Instead, today's best software is created and improved using agile methods. This kind of technology allows software development engineers to continually redesign software based on business and customer needs.
 
    with the advent of modern programming languages, such as Java, PHP, Python, and Ruby, as well as the emergence of rich code libraries and unprecedented low-level services from similar amzon, We are entering another revolutionary phase. Examples of new Web eras, such as Digg, del.icio.us, and YouTube, were developed by a small number of programmers. In order to create today's software, you just need to have some really talented programmers on it. In this article, we will describe where software development is going today and where the future is going.

Why the waterfall model will fail

Non-technical people tend to think that software is a very flexible or easily modified thing, that it has no visible touch of the constraints, so can be arbitrarily modified at any time. Of course, this is a mistaken view. Like any mechanical system, software has design and architecture; it's not as flexible as it looks.

However, the accelerated development of the business requires people to constantly modify the software. The old method of development has completely failed to meet this need. Using the waterfall model, these modifications are not possible, the development cycle will be very long, the system will consume too much human, material cost, and usually the final development of the software is not easy to use.

Figure 1, Waterfall software development model

The problem with the waterfall model falling behind is arrogance. This arrogance comes from the belief that we can produce a perfect system overnight. The second problem with the waterfall model is that it is a growth method that is not suitable for dynamic systems, and it is this evolutionary idea that leads to the introduction of agile methods.

Agile methods-born for evolving software

In the early 90, many agile software development methodologies had emerged. Although they differ in detail, they are generally ideologically consistent: they all believe that there is a need for rethinking software development methodologies. First, the software should have to accept the reality of being modified. Today's vision and needs may have changed tomorrow, and software needs to respond quickly to these changes. In order to face this challenge, the agile approach advocates simplicity. Make the simplest system that meets today's needs, and be prepared to revise tomorrow.

Figure 2, Agile software Development principles

The two technologies advocated by the agile approach deserve special attention: refactoring and development testing. Martin Fower, in his classic works, elegantly called Refactoring (refactoring): To improve the design without changing the way existing codes work.

Figure 3, refactoring

Refactoring allows agile systems to accept modifications while maintaining the stability and efficiency of the software. As a decorator constantly changes and perfects the layout of your furniture, agile developers can constantly modify the code to improve his product as a whole. The code is constantly being modified to ensure that we end up with the simplest and most appropriate system that can reflect what we need right now.

Software systems created with agile methods are much more successful because they have been improved to adapt to changing requirements. These systems, like a living thing, can be constantly changing to accommodate the changing needs. There is no doubt that the agile approach has had a big impact on the way we think about developing software today: Dynamic programming and continuous programming.

Code base makes software development easier

As we discovered a better way to develop software, we also found a better programming language. C language is replaced by C + +, and then comes out of the Java language. Perl is great, but PHP and Python further optimize it. Recently, in addition to Ruby, it has become one of the most popular programming languages because of its natural characteristics in expressing code. To sum up, today we have a lot of excellent programming language.

Although the choice of programming language is usually a sensitive topic, in fact we choose not the language itself, but let us make a different choice is the language of the code base with the strength. What makes Java replace C + +. Yes, Java is a simpler language, but in 10 years people have been good at using C + +, it is not as Java. The problem is the code base. C + + never has a standard library owned by Java. What gives Java the edge is its rich, reusable code base. So is PHP. It has become the best choice for Web developers because it has a wealth of functionality to support Web and database processing.

Figure 4, compare who's got more stuff in the library.

In addition to the rich code base that modern programming languages bring, the open source movement has also contributed a lot of code to the global software community. Most notably, the Apache Foundation alone has created a lot of high-quality reusable code. We have now entered a new era, and we have a strong foundation for creating complex software systems. Now that we have both methods and tools, what does this mean for future software development?

The future of software development: the world of talented programmers

In the early days of software development, people struggled to create a good system. More and more people are joining in to achieve this goal, but it makes things worse. But with the recent outbreak of social networking sites, we've seen a new and interesting phenomenon: a handful of developers are now able to create systems that can be used by millions of of people. How did this happen?

The secret is that these systems are just a few talented software developers who do it alone. As long as the discipline of software development is followed and the enthusiasm is high, efficient engineers can build a great, complex system of their own.

Mastering a modern programming language, with great code base and agile programming methods, many smart guys in the shop can get things done faster and better than the regular ones made up of ordinary developers.

Figure 5, three kinds of tools for software development

    in the next few years we are most likely to see the following changes:
 
    enthusiastic senior software engineers will be in short supply, and of course they will get a higher return.
 
    developers who do not have great programming skills will have to fend for themselves.
 
    The changes we see today in the social software market will gradually be staged in the enterprise-level market.
 
    software outsourcing will have fewer and less economic implications.
 
    Computer Science will continue to be a highly competitive and respected area.
 
Conclusion
 
    Ironically, the development of software has completely followed the trajectory described in the myth of the human Moon. 20 years ago The right thing still applies today, just to argue that its right reason has changed. The combination of amazing programming languages, basic libraries, and agile methods allows us to liberate ourselves from the old software development dogma. Only a handful of great engineers can now successfully create highly complex systems. Technology has finally returned to software engineering.