A new generation of software has begun to emerge. These are tools that take UML diagrams and transform them into code. Humans have been creating software now for nearly a generation. This wisdom has begun to distill itself into "Design Patterns" and into a higher order of meta-thinking about systems design.
The idea behind UML to Code tools is simple enough and the progression follows a path something like this:
In the bad old days you had to toggle in programs one bit at a time. Then there were switch boards allowing bytes at a time to be toggled in. Programming involved all sorts of unrelated skills such as knowing how to toggle in code from 3x5 cards. There were no languages beyond binary.
Later the binary got covered over in a veneer of language that could be assembled into binary. Life was better. When higher order languages were introduced that could translate formulas into assembler and then binary there was some resistance. Surely, there was no way that these compilers could produce binary that was as good as the binary created by a talented human programmer? In time this argument was forgotten and the age of Programming Languages dawned on the planet.
After thrashing around for a while on how to best represent programmer thought in programmer language some defacto paradigms started to evolve as the ways that various classifications of human minds work began to be understood. In time we began to see common problem solving patterns. These patterns eventually began to see formalized expression in an implementation independent way.
Just as assembler was more expressive than binary, the programming language more expressive than assembler, wouldn't this meta formalization be even more expressive? And, shouldn't it be possible, once they were formalized, to transform these diagrams into programming language representations that would find their way all the way down to binary?
This is the early dawning of that next phase of software developments evolution. We have had some faltering starts at it. Several commercial products have tried to add a "visual" component to their development tools but these miss the power of the meta-language called UML. Just as it took time for the first compilers to get "good enough" to over come the argument that no "code generator" could do as well as a human programmer, these tools face that problem too.
In time they hold great promise of freeing the programmer from unnecessary minutiae allowing them to build bigger bolder castles in the air.