Bots That Write Code Are Landing on Planet Earth

The future of work for application development and delivery (AD&D) experts will have to change!

Today, roughly 70% of the work is about developing glue code and wiring things together. From the UI front end to the back end of apps and in the integration layer, there are lots of repetitive tasks, boring 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.

In addition, considerable progress is being made by traditional tech giants, like IBM with AI for code and Project CodeNet and Microsoft through GitHub Copilot. Both bring 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 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 (see figure) 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 based on the following core operating principles:

1. Design artifacts must be in a standardized format.
2. 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.
3. However, the code generated can be readable if TuringBots are cowriting code with developers (e.g., Microsoft’s GitHub Copilot).
4. TuringBots will have to meet several predefined service-level agreements and constraints.
5. Extension points will be defined as services in design artifacts if custom code is necessary.
6. 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 for building 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. But if someone is leveraging that technology with ML, we’d love to hear about it (see contact details below).
• 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 article, by Forrester’s vice presidents and principal analysts Diego Lo Giudice, Mike Gualtieri, Jeffrey Hammond, is here. It part of a three-article series, and the above was adapted from the second one.

The views and opinions expressed in this article are those of the author and do not necessarily reflect those of CDOTrends. Image credit: iStockphoto/monsitj