The History of Visual Development Environments: Imagine There’s no IDEs. It’s Difficult if You Try.
There was a time when programs were written in text editors. And when competition between C++ vendors was actually fierce. Step into the time travel machine with us as we revisit the evolution and impact of the visual development metaphor.
You have to have a few gray hairs to remember the time when a developer wrote an application in a text editor, saved it, exited the editor, ran the compiler, wrote down the error messages on a pad of paper, and then traced back through the code again.
This was in the days before Visual Studio and real-time code checking and one-click links to errors being taken for granted. It was otherwise known as the 1980s.
That’s not to say that, early on, there were no attempts at visual programming, where the application is built by visual elements that represent lines of code, actions, or objects. The IBM mainframe had a program called FSE, Full Screen Editor. But somehow it didn’t have the same impact as did integrated development environments (IDEs) on those newfangled “microcomputers.”
In 1983, Borland Ltd. acquired a Pascal compiler from a Danish programmer named Anders Hejlsberg (you may have heard of him) and released it in the U.S. as TurboPascal, which featured an integrated editor and compiler. “That was very handy, to have the error messages from the compiler right there in the editor that you could click on and go to the error,” said Charles Petzold, long-time Microsoft development author and MVP.
David Intersimone, a long-time Borland executive in charge of developer relations who is now with Embarcadero Technologies, remains partial to TurboPascal. “I always liked to claim, in the early days of the PC era, that TurboPascal really was it, particularly because of its price [$49.99]. The compiler, error checker, ability to run in memory, all of that was in the first release on,” he said.
Visual development in its earliest stages was limited by what the PC could do. But for the IBM PC in the early 1980s, with its single-tasking operating system and 8- or 16-bit hardware, the previous software development process was text edit, compile, write down the errors, and debug with your eyes.
Both the hardware and the PC culture needed to advance first, said Jeff Duntemann, programmer and publisher of Visual Developer magazine, which was published until 2000. “The PC culture was inherited from the IBM mainframe world,” he said. “The graphics in that era weren’t very good. Until we had Windows to provide the basic ideas of displaying things in windows, PCs had a foot and a half back in the mainframe world,” he said.
Microsoft officially launched Windows in 1985 but it was a typical Microsoft launch: not very usable for about two or three revisions. It wasn’t until Windows 3’s release in 1991 and then Windows 3.1 in 1992 that people began to think visually in their use of computing, and with it, programmers began to think visually in terms of application design.
The Roaring ’90s
Windows 3.0 and 3.1 finally made a graphical desktop useable on the PC, and that’s when visual design finally started to take off. Beginning in the early 90s, typical PCs used 32-bit processors, sported more than 640k of memory, and more importantly, they had a graphical desktop and a mouse.
While TurboPascal launched the idea of an integrated development environment, Duntemann credits Microsoft’s Visual Basic (VB), launched in 1991, with being the first real IDE.
“If VB hadn’t happened, Delphi wouldn’t have happened, and Visual Studio wouldn’t have happened, and PC guys would be pounding out forms textually,” he said.
Productivity “went through the roof” and we started to get out of “the death grip of textual editing,” said Duntemann. “Mainframes were purely textual worlds. We were now allowed to think about programming in graphical terms. That may be the largest single change that visual products made at that time to the programming community.”
It also launched a bit of an arms race. Microsoft was in it with Visual Basic, a nod to its heritage since the company was launched on a BASIC compiler for the Altair computer in 1975. It later added Visual C++ and then Visual J++, a Java compiler that produced native Windows apps from Java code, to the extreme consternation of Java’s creator, Sun Microsystems.
Borland would fire back in 1992 with Delphi, a Pascal-based integrated development environment where you designed, coded, tested, and debugged all within the interface of the program. In addition to helping developers writing their own code, Delphi introduced the concept of building applications from pre-fabricated objects.
The inspiration for Delphi was “How could we rapidly and visually build apps,” said Intersimone. “Initially, it was no code. Just drag and drop components. Ultimately for us it was, ‘How can we get more done with less people.’” Several years later came C++Builder, which put a Delphi-like interface on top of a C++ compiler.
Even Symantec got into the fight thanks to its acquisitions of THINK Pascal, THINK C, Symantec C++, and Visual Café for Java development. Symantec’s development tools never gained significant traction, however. Eventually the company exited the tools business in the late 1990s.
The timing of IDEs was also perfect for a new form of development: the Web. While HTML code is hardly as complex as most C++ or Assembly language programs, for the beginning developer, HTML was still a challenge. In the mid- to late-1990s, visual webpage builders used the same drag-and-drop methods pioneered in Windows application development just a few years earlier. Among them: Microsoft’s Front Page, which built webpages that looked especially good in Internet Explorer.
Programming for the Masses?
There’s an old joke: If you build something even an idiot can use, only an idiot will use it. IDEs took programming out of the realm of arcane coding books as thick as a phone book and reduced many hours of work to just a few clicks.
Did it democratize programming, or enable bad programming? A little of both, say the veterans.
“My impression is that as a proportion of total programmers, the amateurs have kind of decreased,” said Petzold. “It used to be you could load up BASIC and without knowing too much, write a little basic program. BASIC was taught to people getting Liberal Arts degrees.”
Where IDEs have dumbed down programming and caused bad habits is this idea of dragging and dropping controls, where you can design a window by dragging buttons onto it, Petzold added. “IDEs say you can do something, not whether you should do something. It’s one form of laziness, not trying to figure out the right code but testing a bunch of possibilities and finding which one works,” he said.
Petzold gave one hilarious example: He once saw a student in a tutorial who was tasked to build a spreadsheet application use a separate text box for every single cell in the spreadsheet. Needless to say, it wouldn’t work. The text boxes had no connection to each other to do calculations, like a spreadsheet needs.
But, Petzold also said, he couldn’t live without IntelliSense, a feature in Visual Studio that suggests things like objects and libraries as you type. “For modern operating systems, it’s just so essential. You can’t remember everything, and it’s so essential for the IDE to tell you what’s allowed in this context. I don’t think there’s any way a programmer today could give up IntelliSense,” he said.
Intersimone believes the advent of the IDE made programming more accessible. “We use the term ‘standing on the shoulders of giants.’ They aren’t making components but they use existing components. So, if anything, [IDEs] made great programmers greater, but it also made good programmers better,” he said.
IDEs made developers do better work without having to do the heavy lifting of writing all the visual features, such as menus, windows, and radio buttons. “Ultimately you still have to write code to do things like business logic. Someone still has to program that,” Intersimone said.
Duntemann said the IDE did enable bad behavior but the good outweighed the bad. “One problem that came out of visual development is a lot of people who didn’t understand the basics of software design were able to gin up programs that ran. They were hideous but they ran. It was always the case, but it was a lot easier with Visual Studio and Delphi to create programs,” he said.
But the tradeoff for the pros was too good to ignore. “The big change was the time you used to waste designing GUIs, how you put in forms and check boxes. That used to be done textually and it was a nightmare. When visual form design tools began to appear, productivity for generating user interfaces went through the roof,” Duntemann said.
Fast Forward to Today
IDEs certainly didn’t stop with those early tools. It would be impossible to discuss the history of IDEs without mentioning the advances offered (over time) in the open-source Eclipse (which we first encountered as IBM’s Visual Age for Java).
The newest crop of IDEs takes advantage of cloud computing. Today’s IDEs – including the ones provided by Mendix, as we feel compelled to gently and tastefully point out – bring the entire application development lifecycle under one roof. Developers can create applications without any traditional programming abstractions, using metadata-driven application models, and achieve similar productivity gains when it comes to application deployment. They uniquely combine visual development with integrated deployment, monitoring, and sometimes even collaboration, instantly available in the cloud. One day we may look back at this point in computing history with nostalgia and wonder how we ever did without these capabilities.