Low-Code and No-Code Programming: Purpose and Strategy

In order to reduce the deployment times of software packages, controllers, and other automation equipment, many automation hardware companies are turning to alternative solutions.

Although the terms "no-code" and "low-code” programming are commonly used by engineers and designers, they are not official programming languages, technically speaking. They're simply a conceptual description of coding that can be performed quickly by someone who may not be a traditional computer programmer. Robotic programming applications, programmable logic controllers (PLCs), machine vision applications, motion controls, and many other technologies are leveraging the advantages of no/low code interfacing.

 

What is No-Code Programming?

No code interfacing requires no actual coding at all. In these interfaces, users build all of the control commands into graphics and point-and-click interfaces. These interfaces can be menu-driven, where the user selects important components from drop-down menus, or can take the form of “training,” often using machine vision to look for specific items by placing the items in the camera’s view and clicking on the item. It can also mean manually moving a robot through its range of motion to show it where to perform actions.

 

Figure 1. Learning from an early age, most STEM programming IDEs (like the Lego Mindstorms platform) use variations of no-code environments. Image used courtesy of Lego

 

What is Low-Code Programming?

Low code interfaces often start out as no code interfaces, but have a little extra capability. Somewhere in the user interface, there is a way to customize some of the code to meet more specific needs. This is useful for recalibrating sensors, recording new data, changing coordinate systems for robotic motion, or performing some other advanced function. The purpose of low code interfacing is to allow the user some latitude in the machine’s capability, but only through small tweaks to the original code.

 

Advantages of No/Low Code Interfaces

No/low code interfacing offers some attractive advantages over traditional coding. The speed at which code can be created and deployed can be a major advantage, but they have some subtle hidden advantages as well.

 

Figure 2. Robot teach pendant programming can use graphical elements to describe motion and gripper operations. Image used courtesy of FANUC

 

Easy Training

With the worker shortage hitting most industries, finding, developing, and maintaining talent is a major challenge. No/low code interfacing removes some of the barrier-to-entry for shop-level technicians so that they can perform engineering work without the steep learning curve associated with learning a text-based language. It also helps bring new employees on board and up to speed much more quickly than placing them in front of a terminal with a C++ textbook and hoping they learn to code.

 

Shortens Downtime

No/low code interfacing makes installation and initial setup of automation equipment much easier. This means less downtime spent learning and training new automation systems. It also means less time spent training new workers on the system. The simpler interface also means that troubleshooting is much faster.

Consider a situation where a new hire is updating some code. For some reason, the code does not perform properly. In a text-based language, the system will be down until the new hire finds the missing bracket and figures out why there is a stack overflow or some other such common problem. In a no/low code language, keeping track of which variables are “in the loop” or “out of the loop” is visibly easier. There’s no strong syntax to track.

 

Figure 3. Text-based languages require practice and can be difficult to troubleshoot. Image used courtesy of Wikipedia

 

Universal Language

One of the neat possibilities with no or low code interfaces is that the use of graphics over text makes communication between cultures more clear. Even though text-based programming languages use only a few English words for commands, such as “LOOP” or “IF/THEN” type statements, variable names, class names, and other naming structures can be lost in translation. No/low code interfaces often rely on pictures to communicate a message, and many of these pictures and symbols can be understood across language and cultural barriers.

 

Drawbacks of No/Low Code Interfaces

There are a few drawbacks to no/low code interfaces. By reducing the amount of background knowledge required to program devices, the code must perform many of the tasks behind the scenes. What the code does behind the scenes is often not customizable, limiting some of the potential of the program as a whole.

 

Reduced Capability

When this author was first learning different programming languages back in the 1990s, his father told him, “programming languages are like knives. QBASIC is like a butter knife. You can get the job done, even if it takes a while, but you won’t hurt yourself. C++ is like a double-edged razor- the job is done quickly, but you can cut yourself badly. PASCAL is like a pocket knife, somewhere in between.”

The same holds true for these no/low code interfaces. The simplicity means that some features are left out. Perhaps the coding is safer, in that it is easier to understand, troubleshoot and document, and maybe it helps prevent crashes (both software and physical robot collisions). However, in doing so, it does remove some capability.

 

Proprietary

One of the major disadvantages of no/low code interfaces is that they are usually proprietary. Because most of the actual coding is behind the scenes, this code is often specific to the equipment manufacturer. As such, the code is only applicable to the manufacturer. While the learning curve on these no/low code interfaces is not steep, it often must be relearned if future control systems are switched from one manufacturer to another. Furthermore, depending on the pricing model, the plant may be stuck paying for a subscription service for the proprietary code, realizing that switching away from it to text-based code at a later time will be a major setback.

 

Figure 4. Comparing a low-code environment on the left side (progressive lines of code, but each built with simple, intuitive graphical icons) against a no-code program setup on the right (workflow steps all based on images with simple numeric data entry, designed for one single task). Modified image used courtesy of Universal Robots and OnRobot

 

The Future of No/Low Code

Any task that is repetitive, boring, dangerous, or subject to error should be delegated to a machine instead of a human. This is the role of automation. Many of the steps in programming can be repetitive, boring, or at least subject to error. No/low code programming will continue to grow, as some of these tasks can be pushed into simple graphics blocks that can be placed much more easily than lines of code.

Some programmers will resist this change. They will see it as programming made too easy. It can also limit some more complex, custom functionality. Yet those same programmers are using coding languages (few are doing machine-level programming), using IDEs on computers built with transistors instead of vacuum tubes. They’ll work with an electric light instead of a candle.

The main point of programming is to create a functional system, and when skills and time are both in limited supply, it can be advantageous to rely on different methods that provide strategic advantages in many cases, when both time and skills are in short supply.

 

Featured image used courtesy of Adobe Stock