What is evolutionary design?

Design is part of the programming processes and as the program evolves the design changes.

Evolutionary design as promoted by extreme programming is a balance between adhoc (no design) programming and planned (one-off) design. It creates the balance by applying the term “iterative” to its fullest potential. The fact is that in software development, the design often evolves as programming is being done. In other words, the “best way of doing things” often evolves as the team learns on the project. There is no way to anticipate all the issues that can come up before you start programming. This is why planned design doesn’t work. If the design is done in a completely separate phase from the implementation, programmers are going to run into shortcomings in the design, and because most programmers are lazy ;), they will just code around it. This means that without the evolution of the design, planned design will dissolve into no design for all the issues that were found after the design was made. This is why the evolution of design should be acticipated and yes, planned.

What enables evolutionary design?
To achieve this, a number of key concepts are used: refactoring, testing, continuous integration. The team must be able to refactor to keep things as simple as possible. Here, the goal is to keep the code as easy to work with as possible. Adding new features should be easy if the framework is the best it can be at that moment. If it is not, then someone should have the vision to refactor the design so it can accommodate the new feature. When refactoring large amounts of code, unit testing and continuous integration are of utmost importance. Refactoring is changing the underlying implementation without changing the functional aspects. Therefore, the unit tests should still work. Maybe they have to be adapted if the API has changed, but functionally, they should still work and the units being tested should still do what they used to do. As soon as unit tests pass, integrate. Continuous integration minimizes the need for merging. And a good test framework makes continuous integration possible. This way you know that what is being checked in doesn’t have stupid mistakes in it that breaks everything. As a result, the code base is as stable as it can be.

Summary
Evolutionary design is about making the best decisions you can based on the knowledge you have at any given time. When design and code are allowed to change, you incrementally achieve the best result because you have a working system at every iteration. To me, this combats the chaos that can ensue when the programming phase reveals design flaws. In fact, extreme programming is not extreme at all. It only takes a wish to work in the most efficient way possible.