Evolution of Code Generation Tools

Chris Chartrand, CTO DXterity

Before the language even existed to describe self-actualizing machines, most commonly referred to as the “technical singularity” (coined by Ray Rurzweil), programmers have sought to simplify the challenge of software engineering via automation.

It should also be noted that the descriptive “evolution” in the title of this short post was chosen with some degree of forethought, as the software generation tools closely correlates to the biological definition of evolution that of “a change in allele frequency in a population over time”.  In this case.  Further analogies include:

  1. Alterations often happen via “mutation” when a programmer stumbles upon a creative new way to attack or solve a problem
  2. Alterations are either accepted by the “population” via survival pressures and propagate
  3. Many alterations are negative and are terminated – known as anti-patterns (although some of these anti-patterns persist for much longer than should be allowed!)
  4. Generation tools are by definition heredity in that the new versions are at least partially authored by their forebears
  5. This process is un-guided in the sense that there is no singular goal in mind when software engineers utilize and or create these tools
  6. There are both divergent and convergent strains of tools, depending on the specific niche the code generation tool is meant to solve
  7. Even the notion of generation languages (3GL, 4GL, etc) or conceptually from bitwise logic, through the compiler and instruction layers all the way up through modern enterprise object-oriented languages should be considered evolutionary

In the more modern recent past (I shall skip the distant past in this article for brevity) code generator tools assisted by simply offering snippets of commonly used code.  This evolved into reducing the amount of repetitive code.  An “explosion” was made and deeply ingrained even more recently when developers realized that CRUD (Creation, Retrieval, Updates and Deletions) code could be automated to some or a large extent to assist with model driven development efforts.

As with biological evolution, often a local plateau is reached where the population believes they have reached an apex situation where no further improvement or evolution to survive is required – I would argue that is where a majority of the code generators now reside.  Like 99.9% of all species that have ever existed on earth have gone extinct, so will all these generations of tools as they fail to recognize the requirement to evolve further!  

DXterity enters the picture with a wholly new take on code generations tools – openly acknowledging the giants that have come before it, embracing and extending the technologies into a whole new field in recognition of the huge mountain left to climb – and humbly acknowledging that we are even still at the base camp in this journey.  DXterity goes far beyond CRUD related code and offers full enterprise grade, configurable software solutions out of the box, abstracted on both the data storage technology and language side.  The current iteration of DXterity looks at all facets of enterprise code and implements them in a systematic way, while still allowing and keeping the developer at the center of the construction effort allowing them to override, embrace and extend all areas of development.

So where do we go from here?  As the author of DXterity and having focused my career on the development and propagation of code generation tools for the past 10 years or more, I recognize the odd (and seemingly contradictory) statement that the more you know about a subject the more ignorant one becomes on the subject of that domain.  So having a taste of the complexity and depth of this still immature field in computer science, I can only tell you that I see large improvements are still required in the following high-level areas:

  1. Full neural network driven mutative development
  2. User Interface design and implementation
  3. Closer human/model driven implementations
  4. Further abstraction of language constructs
  5. Further separation and even disconnection between data sources

Excitement abounds and the story and evolution of software generation tools is still in its infancy!  To learn more or further discuss this topic in detail, please feel free to contact me anytime so we can share our visions and passions together.

Leave a comment