The IT industry is continually looking for more effective and efficient ways of building and maintaining software. For many years software engineers have looked at their colleagues in the “hard” engineering disciplines and admired the techniques that have been built-up over the years to build reliable and predicable complex structures. Much time and effort has been spent on trying to bring these sorts of disciplines to the world of software engineering.
Modular programming, structured programming, object-oriented programming – these were all steps on the road to improving the software engineering process. While these methods each lead to improvements at the programming level, they did not address a key issue – that applications are assemblies of large numbers of programs. Improvements are therefore needed not just in how we build individual programs, but in how we build complete applications.
Anyone who has worked as a professional programmer will have noticed quite quickly that there is a lot of repetition in software development. The same functionality is implemented in many programs, especially technical functionality that has to do with interfacing with infrastructure products such as databases, transaction processing systems, user interface technologies etc. If the functionality were exactly the same in each case then things would be relatively straightforward. Unfortunately in the real world the repetitions tend to fall into the “similar but not exactly the same” category. We therefore need processes and tools that help to solve this common problem of repeatedly developing similar functionality again and again.