Every week, I look at a software patent that’s been in the news. You can see previous installments in the series here. This week, my starting point is this story reporting that one of National Instruments’ patents on its LabVIEW software has been upheld. I have not been able to determine for certain which patent was upheld, but I’ve arbitrarily chosen this one as a likely candidate. If anyone knows for sure which patent was upheld, or how I can look that up, please let me know.
Here’s the abstract for this week’s patent:
A method for programming a computer to execute a procedure, is based on a graphical interface which utilizes data flow diagrams to represent the procedure. The method stores a plurality of executable functions, scheduling functions, and data types. A data flow diagram is assembled in response to the user input utilizing icons which correspond to the respective executable functions, scheduling functions, and data types which are interconnected by arcs on the screen. A panel, representative of an instrument front panel having input and output formats is likewise assembled for the data flow diagram. An executable program is generated in response to the data flow diagram and the panel utilizing the executable functions, scheduling functions, and data types stored in the memory. Furthermore, the executable functions may include user defined functions that have been generated using the method for programming. In this manner, a hierarchy of procedures is implemented, each represented by a data flow diagram.
If I’m not mistaken, what this is describing is a program that allows you to create a piece of software by drawing its flowchart. Given that I’m pretty sure I encountered the concept of flowcharts when I was in grade school in the 1980s, I think it’s safe to say that flowcharts were not a novel concept in 1989 when the patent was filed.
But what about the concept of automatically converting a flowchart into a program? It seems to me that this is neither novel nor non-obvious. On the novelty side, one example to look at is Mac OS X’s Interface Builder, which Wikipedia says was first introduced with NeXTStep in 1988. It allowed software developers to create user interfaces graphically, but dragging buttons and other interface elements around on the screen. Software would automatically convert the layouts into code. This isn’t quite the same as the LabVIEW patent, because programmers typically had to write small snippets of code to implement the functionality of widgets, but it clearly demonstrated the idea that you could build software visually and have the computer automatically convert it into code.
On the obviousness point, it’s a commonplace of computer science that a given procedure can be expressed in many different ways, and that software can always be written to convert code from one language to another. I’ve written about Piet, a whimsical programming language whose programs look like abstract art. And the point is very well made by the gallery of CSS descramblers, which shows dozens and dozens of different ways to describe the procedure for de-scrambling the encryption that protects DVDs.
Therefore, both the idea of creating a program via a graphical interface, and the idea that a graphical representation could be converted into more traditional computer code, would have been obvious to the average computer scientist. The fact that most of the software that allowed you to do so emerged in the late 1980s and early 1990s most likely reflects the fact that computers had only recently become powerful enough to make graphical interfaces feasible.
For the sake of completeness, I should mention the other software patent story in the news this week. If anyone can track down the specific patent at issue there, I will do a post on it next week.