Prepare for AI that learns to code your enterprise applications

The future of work for application development and delivery (AD&D) pros will have to change.
Written by Forrester Research, Contributor

The future of work for application development and delivery (AD&D) pros will have to change. Today, about 70% of the work is all about the development of glue code and wiring things together. From the UI front end to the back end of apps, as well as in the integration layer, there are lots of repetitive tasks, design patterns, and custom code written. And what's worse, many teams develop the same code over and over repetitively. The creative business logic often represents the smallest effort. This waste increases even more when you try to build new, creative, and differentiating custom software. 

But as more AI-driven innovation becomes available, more possibilities emerge that can help developers gain productivity -- coming in particular from the enhancements of AI-infused development tools shared, something we outlined in more detail in part one of this blog

In addition, big progress is being made by traditional tech giants, like IBM with AI for code and Project CodeNet and Microsoft through GitHub Copilot. Both are bringing augmentation and automation to enterprise application modernization efforts, coding productivity gains, and simplification for developers. 

Enterprise TuringBots: A Deep Dive Into The Future  

This is where "TuringBots" or SW Bots that help build enterprise software come into play. We coined the term TuringBots in Forrester after the British genius Alan Turing. We believe that in the next five to 10 years or sooner, based on the groundbreaking innovation in AI, like AI 2.0, TuringBots will be created by several tech vendors. Enterprises can look forward to leveraging TuringBots for coding applications better, faster, and bug free. Packaged application business platforms, low code environments, professional development, and testing tools will all leverage TuringBots and are starting to do so already. 

TuringBots will use AI and machine learning (ML) to build models that "learn" from existing code and identify which code generator can meet the business applications and infrastructure requirements to generate and deliver source and executable code. Reinforcement learning seems a likely foundational technology for TuringBots. But various other AI foundational technologies are strong candidates, too: from deep learning models to GPT-3 to neuro-symbolic reasoning (and most likely a mix of all these). 

We do know TuringBots will have to work on the basis of the following core operating principles: 

  • Design artifacts must be in a standardized format. 
  • When delegated to write entire systems, generated code won't — like in the past — have to be human readable. Why? Because TuringBots can regenerate code any time at rapid speed. So, all we'll have to do is change requirements and constraints and — voilà — you'll get the new code. 
  • However, code generated can be readable if TuringBots are cowriting code with developers (e.g., Microsoft's GitHub Copilot). 
  • TuringBots will have to meet several predefined service-level agreements and constraints. 
  • Extension points will be defined as services in design artifacts if custom code is necessary. 
  • TuringBots will generate multiple versions of business applications based on design artifacts and a toolkit of implementation technologies and desired architectural qualities. 

TuringBots Will Change Forever The Way We Build Apps For The Enterprise  

With TuringBots becoming available, roles, tools, and technologies on how we build enterprise apps will change forever. Here are some of our initial ideas and thoughts on the future software development lifecycle with TuringBots:  

  • Application development designers will use tools to design end-to-end application artifacts, a starting point for requirements. We are not implying traditional UML or BPMN model-driven generation here.  

  • Enterprise application architects will define reference application and infrastructure technology stacks (e.g., UI frameworks, APIs, microservices, Kubernetes, databases, continuous integration/continuous delivery toolchains, etc.). IBM AI for Code stack represents a strong starting point that offers AI-infused tools to help. 

  • Solution architects will define application architecture qualities (i.e., non-functional requirements) around availability, efficiency, security, reliability, load, accessibility, etc. 

  • TuringBots will "read" and "learn" all the above application end-to-end design artifacts and quality requirements, including reference application and infrastructure technology stacks. 

  • Together, AD&D pros and TuringBots will build, change, and refactor applications and scale them orders of magnitude faster than current processes, dramatically reducing costs — all as close as possible to button-pushing agility. 

This post was written by Vice President and Principal Analyst Diego Lo Giudice, and it originally appeared here

Editorial standards