A history of robot programming languages
The history of robotic programming is surprisingly complicated, especially with how simple programming has become these days. The history of robot programming is a complicated one, but is necessary to provide some perspective on where we are today and what it means for the future. Why are more and more programming languages invented each year? Surely we must have enough by now?
Prehistory – Automata and computing
Any good history of robotics should begin with Automata. These mechanical marvels of the ancient world were the great-great grandparents of modern automated technology and many were powered by running water. They took a variety of forms including flapping ducks, automated hand-washing machines, and handwriting dolls. The programming method for Automata was not very flexible. As they were purely mechanical, most of them had only one program. To reprogram would mean redesigning the whole machine. They were certainly programmed, but to call this a "programming language" would be a bit of a stretch.
The first real programming language was developed by Konrad Zuse, a German civil engineer, around 1945. He developed Plankalkül, the first high-level programming language. He developed it to run on the first working computer, the Z3, which he had invented a decade earlier. While useful and important in its own way, the first robotic programming language was a decade away.
The three generations of robot programming
The first real "robotic programming" arrived along with the first industrial robot. The Unimate was invented by George Devol in 1954. The robot used a very low level of programming, which involved "teaching" the robot. The user commanded the robot to a position then stored the positions of all the joints. When the program was played back, the joints would move between positions comparing them to its current position. There was no "language" as such, but this process still happens at the low level of modern robot programming languages.
The first robot language was MHI, which was developed in 1960 for the control of a robotic hand at MIT. However, it wasn’t until the 1970s when the first general purpose, robot programming languages really came onto the scene. This was followed by an explosion of programming languages in the next several years.
This is where the complication begins. It’s impossible to cover every single robot language, because there are so many of them. A common way to make sense of them is to focus on the three "generations" of robot programming languages.
First generation languages: Programming by teaching
The VAL programming language was developed in 1973 at Stanford University for use with the Vicarm small research robots. However, it wasn’t until 1977, when Vicarm was bought by Unimation, that the language moved into industry. This was the era of the first generation languages.
First generation languages worked in a similar way as George Devol’s invention. They accessed the robot at a very primitive level and were, therefore, suited to highly repeatable tasks. Most of them were based on existing programming languages that had been developed in the 1950s, such as COBOL, ALGOL or Fortran.
The languages were capable of describing robot functions and motions in a simple way. They were limited in terms of sensor input and communication with other robots. Other examples of first generation robot languages include SIGLA (1974), ROL (1976), FUNKY (1977), and SERF (1978).
Second generation languages: Robot-oriented programming
The need for robot programming languages continued to grow and develop quickly, as robotics itself grew more advanced. However, these early languages also had quite a short life. Of the 22 early robot languages, only 8 were still in use and commercially available by 1982.
Second generation languages were developed throughout the 1980s. They featured more advanced motion control, sensor interface capabilities, inter-robot communication and even some limited artificial intelligence. Instead of just plotting the joint positions, these incorporated a higher level model of the robot, including inverse kinematics. VAL II was developed in 1982 and was designed as a completely new programming language, not just an extension of its predecessor VAL. Other examples of second generation languages include AML (1977), RAIL (1981), HELP (1982), and Karel (1985).
Industrial robotics has more or less stayed around the level of second generation languages. This is likely because industrial robots are traditionally still used for repetitive tasks. However, the languages themselves have continued to develop, gradually incorporating features from the rest of the programming world.
The third generation: World modeling and task level programming
The third generation of robot programming is no longer about specific languages. It’s more realistic to call it an ever-developing set of programming ideas, as it has become almost irrelevant which language is chosen.
Many of the features of the third generation are still largely at the research stage, so even a rough start date for this generation is hard to give. Features include automatic 3-D world models, task level programming (e.g. "move that box over here") and a dynamic understanding of the environment.
Certain features from this generation are, little by little, making their way into industrial robots. For example, VAL 3 is the current descendent of the VAL programming language. It is part of the Staubli robotic suite and incorporates aspects such as integration with CAD and offline 3-D teaching.
The first generation involved direct teaching by movements, the second generation introduced programming in robot languages, and the third generation has introduced teaching by demonstration, machine learning and supervisory control. During each generation, the number of robot programming languages has continued to rise. Now a robot can almost be programmed using almost any programming language, using several different methods.
The future: Self-learning robots and beyond
What comes beyond the third generation of robot programming? Self learning robots?, plug-and-play software components? or perhaps verbal programming? Although it’s getting easier and easier for end users to program robots with intuitive interfaces, it’s clear that the world of robot programming from a robot producer’s standpoint, continues to get more complex.
See additional stories about collaborative robots linked below.