Recent advances in automatic programming suggest that we stay vigilant to their potential impact on software development. Automatic programming is a branch of AI, and the point is to create a system that can design and implement computer applications automatically. Today, the most practical application of automatic programming appears in low code platforms.
We will explore the current state of the art in automatic program synthesis, with an eye on the future. And we will look at low code platforms with some example code – the code auto-generated by the platforms. A few popular low code development platforms seek to integrate limited AI-based auto coding functionality.
Among these is PowerApps, which implements limited automatic code generation. Seasoned .Net developers are very familiar with MS apps which automatically generate an enormous amount of code around form objects and properties in Visual Studio. This trend expands on low code platforms. Here are several leaders in the field:
The core capability of these low code application platforms is not really driven by artificial intelligence. In other words, it’s not automatic programming in the AI since we learned in computer science. Instead, these developer tools emphasize pre-built apps. This is exactly what it sounds like.
As developers know well, a lot of form object creation is redundant and can be fully abstracted. Abstraction in object-oriented programming is well known too, and pre-built apps fully exploit object-oriented data abstraction to create most a new application without programming. Here are the basic functions of low code software development platforms:
In PowerApps, for example, you can design and build a business app from a model called a canvas. No programming is needed. Provided that the database format is standard. There is automated support for sharing the new app to browsers and mobile devices.
Excel was among the first low code platforms! Although, we don’t usually think of it as such. When you record a macro, Excel generates code in visual basic for applications (VBA) according to each action you take. In fact, this method of using a graphical user interface to create programs in the background was one of the predecessors of today’s low code platforms. Here is an example in which a user records the steps to select a column of cells, sort them, and sum the contents:
Sub SortSum()
Range("A1:A10").Select
ActiveWorkbook.Worksheets("Sheet1").Sort.SortFields.Clear
ActiveWorkbook.Worksheets("Sheet1").Sort.SortFields.Add Key:=Range("A1"), _
SortOn:=xlSortOnValues, Order:=xlAscending, DataOption:=xlSortNormal
With ActiveWorkbook.Worksheets("Sheet1").Sort
.SetRange Range("A1:A10")
.Header = xlNo
.MatchCase = False
.Orientation = xlTopToBottom
.SortMethod = xlPinYin
.Apply
End With
Range("A1:A11").Select
Range("A11").Activate
ActiveCell.FormulaR1C1 = "=SUM(R[-10]C:R[-1]C)"
Range("A1:A11").Select
Application.Goto Reference:="sortsum"
End Sub
This program was generated automatically by the Excel user interface. Note that the user need not know anything about programming to create this program! Each of the menu items selected to take some action on the data in the spreadsheet corresponds to a method in the VBA language. And this code can be run as often as needed like any other app.
As we’ll see, this is the early antecedent of automatic code generators like PowerApps. Visual Studio likewise figured as a pioneer automatic code generator. Each time a developer adds a form object to a project or adds a button to a form, Visual Studio adds hundreds of lines of code for pre-built app classes, methods, objects, and properties in the background.
If needed, a developer can open that code to fine-tune the objects as needed. However, with PowerApps a non-technical user can build an entire app and connect to a standard database to provide many standard services, including predictive analytics.
We want to explore the extent to which artificial intelligence will enhance low code developer tools. Within PowerApps it is possible to embed predictive analytics and even basic human interaction using natural language and speech processing. This is possible by integrating PowerApps with Azure functionality. What is the potential for AI in low code platforms?
If truly intelligent automatic programming should emerge during the next ten years, what would be the impact on software development enterprises in general? Would AI replace software developers?
Or, would engineers simply require a new level of training to implement AI-based software development? We will delve into these questions and reflect on the most recent research in the field.
Traditionally, the purpose of programming is to automate a process, like calculating the balance of your mortgage, saving it in a database, and sending you an email with the balance due. The purpose of automatic programming in such a vertical finance application is a lightyear beyond.
The purpose is to create a system that will write that financial management software application using artificial intelligence – without a programmer! With this distinction in mind, let’s propose a basic definition of what we mean by “automatic programming” in the simplest terms. Ideally, we want to tell the system what the application should do in ordinary language.
In return, the system would automatically generate the code, compile it, install it in our computers, and run it. Naturally, the program should be free of errors, after running test suites to verify itself. If I am having trouble operating the new app, the system should be able to help me with instructions. Is this too much to ask? As of today, this is way too much to ask.
Nevertheless, it is useful to define the ideal so that it has a frame of reference and comparison for today’s technology. Presently, low code programming platforms can provide only limited coding assistance – a far cry from real AI.
The best way to illustrate how far we are from the above ideal is to demo the most impressive automatic programming platform available today. Bayou is one example. Given a simple instruction, Bayou created this Java program to read an input file:
import java.io.*;
import java.util.*;
import java.io.IOException;
import java.io.File;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
public class TestIO {
void read(File file) {
{
FileReader fr1;
BufferedReader br1;
String s1;
try {
fr1 = new FileReader(file);
br1 = new BufferedReader(fr1);
while ((s1 = br1.readLine()) != null) {}
br1.close();
} catch (FileNotFoundException _e) {
} catch (IOException _e) {
}
return;
}
}
}
On the frontier where academic research meets commercial development, an automatic programmer emerged recently. Bayou is an open-source programmer under development at Rice University, and with community participation.
Bayou would rather be called a programming assistant at this stage of development, but the platform couldn’t tell you that itself. The platform is capable of automatically generating code to assist navigation web app APIs – application programming interfaces. Bayou does this by synthesizing calls and queries in the Java programming language.
Researchers at Rice developed Bayou with deep learning methods. Bayou’s training dataset included millions of lines of code extracted from the GitHub repository. Specifically, Bayou is based on a new method of machine learning called “Neural Sketch Learning,” which abstracts coding methods from existing code bases at a higher level than previous methods.
In particular, Bayou uses two classes of learning methods. Let’s look at them briefly here, so that we have a clear basis for understanding the level of AI in automatic coding today.
Neural sketch learning divides the training process in two: statistical learning, and higher abstraction learning. Statistical learning algorithms figure out the architecture of loops and conditions. Meanwhile, a combinatorial and syntax-guided synthesizer works out low-level code features like variables and data typing. According to the researchers:
“Our approach learns over sketches: tree-structured data that capture key facets of program syntax. A sketch Y does not contain low-level variable names and operations but carries information about broadly shared facets of programs such as the types and API calls. During generation, a program synthesizer is used to generate programs from sketches produced by the learner.”1
You can try out the platform online at askbayou.com When an engineer enters an API call, the program intuits code from known code examples gleaned from its prior study of known similar calls. Basically, if you enter a call like “Call URL,” the Bayou will start building an interface that looks like a web client.
Bayou’s performance is quite impressive to programmers, but non-technical users will be underwhelmed. What are the limitations? Well, at this point you need to be a Java coder yourself to be able to use and understand how Bayou works. That’s a long way from the ideal automatic programming we described earlier.
But as we will likely see during the next 10 years, with 18 million programmers looking for the next big breakthrough, progress toward the ideal is inevitable. Bayou is exemplary of current methods in machine learning used to write software automatically. But there is a chasm separating this platform from low code platforms commonly in use today.
The missing pieces to bridge this chasm will require substantial breakthroughs in AI-Hard problems such as natural language processing. Chances that problems in the AI-Hard realm can be solved in the next ten years are not high. In the meantime, what are engineers doing with the trifle of automatic programming we have available today?
Commercially available products in this realm are often marketed as low code development platforms. But there is a catch.
The majority of features and functionality offered by low code platforms today have actually been around and available for many years. Users of Microsoft products such as Excel will understand.., Excel generates programs in the VBA language called Macros. Recorded user gestures are extended to the concept of low code app development.
Developers who are familiar with Visual Studio will likewise recognize the automatic code generation tools this platform. Visual Studio manufactures thousands of lines of verbose code which even with a simple gesture, such as creating a new form object in an application. Have a look at this auto-generated code:
'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:2.0.50727.1433
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict On
Option Explicit On
Namespace My.Resources
'This class was auto-generated by the StronglyTypedResourceBuilder
'class via a tool like ResGen or Visual Studio.
'To add or remove a member, edit your .ResX file then rerun ResGen
'with the /str option, or rebuild your VS project.
'
<summary>
' A strongly-typed resource class, for looking up localized strings, etc.
'</summary>
<Global.System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0"), _ Global.System.Diagnostics.DebuggerNonUserCodeAttribute(), _ Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute(), _ Global.Microsoft.VisualBasic.HideModuleNameAttribute()> _
Friend Module Resources
Private resourceMan As Global.System.Resources.ResourceManager
Private resourceCulture As Global.System.Globalization.CultureInfo
'
<summary>
' Returns the cached ResourceManager instance used by this class.
'</summary>
<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)> _
Friend ReadOnly Property ResourceManager() As Global.System.Resources.ResourceManager
Get
If Object.ReferenceEquals(resourceMan, Nothing) Then
Dim temp As Global.System.Resources.ResourceManager = New Global.System.Resources.ResourceManager("TradeCredit_08.Resources", GetType(Resources).Assembly)
resourceMan = temp
End If
Return resourceMan
End Get
End Property
'
<summary>
' Overrides the current thread's CurrentUICulture property for all
' resource lookups using this strongly typed resource class.
'</summary>
<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)> _
Friend Property Culture() As Global.System.Globalization.CultureInfo
Get
Return resourceCulture
End Get
Set(ByVal value As Global.System.Globalization.CultureInfo)
resourceCulture = value
End Set
End Property
End Module
End Namespace
When a property is configured in the UI, the Visual studio creates the code in the background. This is the domain of low code application platforms today. The scope of their capability to generate code automatically is impressive. But as we will see, these platforms rarely implement actual AI; what they’re really doing is making assumptions.
Much of the functionality we need in software apps is repetitive; we recreate a lot of the same code, hopefully with an innovative spice. Developing accounting applications involves mostly repetitive tasks on the part of programmers.
It is precisely the repetitive coding tasks like form creation, database connectors, and automatic user interface creation that low code platforms do today. Such tasks are the target of programming abstraction techniques. Although this technology is not trivial, we should keep in mind that it is not artificial intelligence.
Machine learning finds application in forecasting applications on the Azure platform. The primary use is predictive analytics. But the whole suite of Microsoft apps cannot be said to operate generally from an AI core. PowerApps is Microsoft’s contribution to the arena of low code development platforms.
But the platform stitches together docs and data from the other apps along with automated form and UI generation. There is no surprising AI component on the menu. Assistants and wizards help you find a missing library to add to your project. This, of course, means that a lot of developers are building essentially the same app over and over.
And the existence of apps that help you build apps is more evidence that just begs the question: why are there so many redundant applications out there?
Hundreds of testware apps now race to integrate machine learning concepts. And automatic coding of test scripts is at the top of every wish list. Limited success can be observed in the computer vision algorithms of Tosca and others. Splunk and others contribute performance metrics which engage ML methods.
But the AI involved still must be stitched together by a team of data scientists from MIT. It’s not artificial intelligence yet – just artificial.
We are a long way from an auto coding platform where business-facing users can ask a testware system to update a script from last week to compensate for three-page elements that now suddenly have a new XPath. Indeed, smart XPath identification is a hot topic now. The use of an xpath identifier is a special focus of ML-based testware applications. Testware programs now assign unique IDs to track XPaths through code revisions.
Intelligently identifying page elements leads to a more successful area: computer vision with machine learning. Right now, computer vision algorithms show about 75% accuracy at recognizing the visual completion of a page. This only works if code changes did not alter the appearance too much.
This is the rather primitive state of the art in one of the most fiercely competitive areas of software development.
Numerous sources claim that we now have over 18 million software developers worldwide. Many developers still perform comparatively mundane tasks which can already be automated. In fact, it’s easy to find a project description admonishing coders from using pre-built app components!
The classic question is this: is it more efficient to look for an automation tool for an ad hoc data conversion, or to get a traditional developer to do it manually? If we look at how processes were automated in the past, the answer is that manual tasks will be gradually replaced by automation. Automating automation itself will be significantly more complicated.
That is not to diminish the advance, but to be practical about the limitations. Most of what can be automated is a repetition of what has already been done. That’s possibly a minor innovation, but it’s not AI. The evolution from straight SQL to PostgreSQL will illustrate. This will show how far we are from intelligent automatic coders which generate SQL queries from NLP:
Suppose I open the natural language interface – conversational agent – and say, “Computer, let’s build a new version of SQL.” Let’s imagine the actual dialog between humans and computers: “Computer… SQL is great, but I want a version that is like an object-relational database, one that is more compatible with object-oriented programming classes!
I would like to create an ORDBMS! One that can see relationships in data by recognizing object similarities!” Technically, the first difficulty is inference. “Make ordinary SQL more like an object-oriented database.” Current AI cannot understand such inferences. Even human programmers have some difficulty with communicating subtle inferences, and a lot of trial and error is waiting around several corners to get what a client actually asked for originally!
As a coder, I am constantly asking the question, “What skills are going to be critical for me to stay viable in the field?” Two years ago, a clear answer to that question was machine learning. ML was at the top of every list of fastest-growing tech skills. Now the world is utterly saturated with ML apps and developers!
An answer to such a question is only an ephemeral panacea. We will have to ask that same question more frequently in the future!
Recently, the big trend is to replace the run-of-the-mill javascript code with Angular and Vue. The vogue is to make old apps look like single-page apps. This type of trendy migration is the target of future computing abstraction. But the point is that a lot of developers can still get jobs doing very ordinary coding without any knowledge of AI.
Even as the feverish race of emergent technologies heats up, legacy systems continue, and they require programmers with legacy skills! Many years and an opaque forest of trial and error must be traversed to discover which technologies will survive and require developers. Distilling the useful point, a lot depends on the people involved.
Some want bleeding-edge new innovation, while others want to relax with a tried and true legacy system. They will both likely continue for a long time because the bleeding edge tech is always expensive. For these reasons, both new and old methodologies will likely persist for at least ten years hence.
Computers and robots replaced millions of human workers in the last decade. Will they also replace the engineers and programmers who created them? Our study shows that it will not happen soon, and certainly not in the next ten years.
The question is a hot one. Coders stand to lose jobs or at least need training in automated developer tools. And globally, the viability of software development enterprises depends on exploiting the most efficient automation tools available. Their continued competitive strength will depend on these answers.
Straightforward enterprises such as accounting, mortgage brokers, paralegals, medical records processors are the obvious targets of automatic programming platforms Those vertical apps have rules which can be canonized by programmers. As such, they are the best candidates for object-oriented abstraction programming and automation.
Extending that reasoning in the age of AI, some programming of those tasks will also be automated, reducing the need for coders.
A banking app needs certain variables to be private in scope. Such an immutable fact can be codified. The amorphous situation of the moment is: we’re not there yet, and we don’t yet know exactly what the course it. However, with 18 million programmers looking for the next brilliant innovation we’ll get there inevitably.
An example that may seem less trivial is the coding of automatic stock market traders called program traders. Now that all brokers use ML to forecast values and trades are made on this basis, it is, therefore, reasonable to assert that ML programs are actually predicting their own behavior!
These ML methods are now so standardized that they are built into app performance monitoring platforms like Splunk. Such predictive platforms have toolkits for applying ML methods as easily as selecting a column and summing in Excel. The next logical step is to automate the entire process.
CodedUI is a testware app that automatically generates a program from a QA engineer’s gestures while testing an app. This resembles Excel’s macro generator, in that it creates a script that is reusable and modifiable. ML is now being built into this and other testware like Selenium.
The objective of ML in testware is to create a heuristic graph of typical gestures. This is a like a predictive map of typical actions taken by a user. After enough data is accumulated in a model such as K-Means then the ML can certainly be trained to emulate the tester.
The ultimate initiative is that testware like CodedUI or Selenium enhancements could automatically revise test scripts! Now, that is not the same as a test script smart enough to revise itself but is an evolutionary step in that direction. The following code is auto-generated by CodedUI:
[CodedUITest]
public class CodedUITest1
{ ...
[TestMethod]
public void CodedUITestMethod1()
{
this.UIMap.AddTwoNumbers();
this.UIMap.VerifyResultValue();
// To generate more code for this test, select
// "Generate Code" from the shortcut menu.
// Mouse hover '1' label at (87, 9)
Mouse.Hover(uIItem1Text, new Point(87, 9));
<!-- Begin : Background Recorder Settings -->
<!-- HoverKey to use. -->
<add key="HoverKeyModifier" value="Control, Shift"/>
<add key="HoverKey" value="R"/>
}
}
With millions of software developers seeking breakthroughs in AI, progress is inevitable. For enterprises engaged in vertical market application design, the best policy is to stay vigilant and read as much as possible in the field of emerging AI technology.
A great way to stay in the AI loop is to partner with a technology specialist such as ByteScout who is steadily engaged in research and keen to implement new tech when it becomes available. ByteScout is always on the cutting edge, the following technology and breaking academic research, and peering into the future to keep you up to date!
About the Author
ByteScout Team of Writers
ByteScout has a team of professional writers proficient in different technical topics. We select the best writers to cover interesting and trending topics for our readers. We love developers and we hope our articles help you learn about programming and programmers.
JavaScript is one of the most important web development languages used today. It lets you add a wide range of functional features to your websites,...
GOTO statement is used to break execution of flow and move execution directly to label specified. The GOTO statement modifies the course of performance to...