A History of Robot Programming Languages
Posted on May 03, 2016 7:00 AM. 7 min read time
There are so many different robot programming languages! Has it always been this way? Where did they all come from? We look back at the history of robot programming, to try to understand why there are so many options for programming robots.
The history of robotic programming is surprisingly complicated, especially when you consider how simple programming has become these days. If you have read some of our recent blog posts, you'll know how to easily integrate robotic hardware with popular languages, how self-learning robots are on the horizon and how to use simple software modules for common robot functions.
In this post, we're going to take a look back through the history of robot programming to give some perspective on how we ended up where we are today. 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 really begin with Automata. These mechanical marvels of the ancient world were the great great grandparents of modern automated technology, dating from as far back as the ancient Greeks. They were often made of clockwork 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.
To find the first real programming language, we have to jump forward to around 1945, when a German civil engineer called Konrad Zuse 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. But, we're interested in robot programming, not computer programming, so we need to jump forward a bit further.
The Three Generations of Robot Programming
The first real "robotic programming" arrived, unsurprisingly, along with the first industrial robot. The Unimate was invented by George Devol in 1954, who you can learn more about in our previous article. The robot used a very low level of programming (as described in the original patent), 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.
Perhaps 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. In fact, I think it's fair to say that there was an explosion of programming languages around the mid-70s. This is where the complication begins.
From this point onward, it's impossible to cover every single robot language, because there are so many of them. Instead, it makes sense to group them into categories. There are various different ways I could do this, but a common way is to talk about the three "generations" of robot programming languages. Although this is a useful way to group them for this article, I have to stress that many of the languages within the same category were quite different from each other. Also, the dates I've used are all approximate.
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 more or less in the same 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. In 1982, a comparative review by Shin and Bonner described the situation very well when it said "Robot Languages have been developed in an ad hoc manner to meet the needs of a particular robot, thereby resulting in a situation where there are almost as many languages as there are robots." 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 maybe because 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 probably more realistic to call it an ever-developing set of programming ideas, as it has become almost irrelevant which language you choose to program with. There are many good languages which you can use to program robots, as you can read in our Top 10 list.
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 3D 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 3D teaching.
Instead of a "third generation of languages," we could have more accurately call it the third generation of robotics. 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? It's a question we've been asking recently here on the Robotiq blog: 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!
What functionality do you think is still missing in modern programming languages? Did you use any of the more historical robot languages? How did they compare with modern programming? Tell us in the comments below or join the discussion on LinkedIn, Twitter or Facebook.