The History of Visual Development Environments: Imagine There’s no IDEs. It’s Difficult if You Try.

on February 4, 2013

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.

  • Larry O’Brien

    The first IDEs for Windows were Actor and SQLWindows. Actor was based on the Smalltalk IDE and SQLWindows provided the “drag-and-drop” form editor that provided the huge productivity increase that this article speaks of. Visual Basic, when it eventually came along, was immensely popular and very polished but it was not as innovative as implied. — Larry O’Brien (Editor, “Computer Language Magazine” 1989-1994)

  • Gernot

    There was a time when programs were written in IDEs 😉 Today, I find them to be bloated and slow. I love the new “lightness” of Ruby + Sublime Text 2

  • I learned Turbo Pascal at university back in the lat 90’s. I remember what the teacher told us then – it’s not efficient and you will never use it outside school. He was right. Thankfully I later switched to C – and it made all the difference for me!

  • Rob

    GNU Emacs in the 80s provided an IDE before Microsoft’s VB. You could compile, edit, and run all inside Emacs. You can still do that today.

  • Wing

    Oh, I made quite a lot of money out of my Turbo Pascal programs. It easy and quick to develop in. Had some high profile customers too.

  • tmp

    UCSD Pascal (ran on Intel 8080 / Z80) was an IDE. An btw, the original Emacs (ran on Digital PDP-10 under ITS) was written by Stallman long before he started GNU.

  • Mark Tarrabain

    There were IDE’s for programming even back in the DOS days…. long before VB. Ones I had personal experience with were Microsoft Quick C, and Borland’s Turbo-language suite (C, C++, Pascal), all of which were around in the 80’s.

  • aljo

    Not to mention debugging from the source code, and this was in the early 80s. So nice to step through the errors in the compiler output and have emacs open the source file in question .. and even place the cursor on the line in the message.

  • J-F Bilodeau

    Give credit where credit is due. Microsoft did not create Visual Basic. They purchased the product from another company.

  • Geezer

    IDEs and visual debugging with multiple windows, mouse, etc. dates to at least 1977. That’s what we had on Lisp Machines at MIT at that time. Those environments were more powerful than what we have today. Maybe in another 10 years we will have caught back up.

  • shayneo

    I never had the same productivity with C as I had with Turbo Pascal. Turbo Pascal had a bad rap it just didnt deserve because people heard pascal and assumed it was the same limited system that pascal was originally built to be. But borland added amazing stuff to the language with its very deep object orientation (A depth I still havent seen in other languages) , an ability to go Assembler deep with optimization, and a whole host of other language features that gave it the sort of scope that C++ has , without all the fiddlyness and memory headaches C incurs. And it ran line the clappers too. But it did have a rep as a ‘beginners language’. It really was so much more. It was python before python even existed;- A ‘beginners language’ you could also use in a very advanced way.

  • I see no mention of Borland C++/Owl. I believe this was out before VB

  • > Microsoft’s Visual Basic (VB), launched in 1991, with being the first real IDE.

    The idea actually came from Alan Cooper, from which Microsoft built VB:

  • Alan B

    Well done for an extremely Microsoft-centric article that somehow management to miss not only dBase but the whole line up through Visual FoxPro.

  • gngl

    Witness the article author’s ability to make Emacs-based Lisp environments on Lisp Machines (complete with debuggers, code browsers, hypertext documentation etc.), Smalltalk IDEs on Smalltalk computers, the Cedar, Mesa and Oberon systems on their respective machines, and advanced interactive Forth environments on *pretty much anything* magically disappear with the power of ignorance!

  • Sherman

    NeXTStep? Interface Builder preceded and was better than VB. Why anyone attributes anything remotely resembling innovation to Microsoft amazes me everytime I read it. 🙂

  • Jay Schira

    In 1986, I worked with the ExperTelligence IDE coding in object-oriented ExperLisp and a WYSIWYG InterfaceBuilder (IB) drag-drop UI editor with target / action visual wiring for wiring UI actions to Lisp object behaviors. IB was later incorporated into NeXT’s development IDE and now is part of Apples XCode. Amazing that 27 years later the (evolved and matured) tech is still relevant.

  • jeff234

    Turbo C is an Integrated Development Environment and compiler for the C programming language from Borland. First introduced in 1987, it was noted for its integrated development environment, small size, fast compile speed, comprehensive manuals and low price.

  • DelphiRocks

    I agree with you shayneo. I’m still using Delphi today as the author of a CRM system deployed to thousands of customers. I wrote the first version back in 1990 in Turbo Pascal 5.5 and the latest build is going out today in Delphi XE2.

  • Orion Blastar

    There was Visual Parts Workbench for OS/2 before Visual BASIC. Anyone remember that?

  • just_me


  • jmc

    ..and it was all fullly integrated into the MacOS Toolbox and had full OS object support. I know – I wrote that bit while at ET. The first true IDE on the Mac was MacPascal released in ’84. I used Smalltalk 80 and the various Symbolic / LMI emacs dev environments in the early / mid 80’s and they were all rubbish. The first true IDE on any platform that current programmers would recognize was LightSpeed C (later Think C) released on the Mac in ’87. It was not until the late 90’s that anything on Win16/32 even got close. Codewarrior, first shipped in ’93, is still by far the best IDE ever shipped on any platform. Eclipse after 10 years of evolution now runs a close second.

  • dip

    Where are the pictures?

  • FF222

    This could have been a fantastic piece of historical lookback. Unfortunately the author’s total lack of actual knowledge of or experience with the development tools and environments of the last 30 years made it just another piece of modern “IT journalism”: a heap of half-truths and plain wrong information googled together from all over the web, forming a total mess of dezinformation without any real or factual value.

  • judoguy

    MS FoxPro was going strong when VB was starting. Drag and drop controls, debugger, code generation, etc.

  • An_A_C

    Travel just a little farther back in time, when programs were entered on punch cards (Google it), often written by hand on special forms and submitted to the secretary to type in because the programmer wasn’t expected to know how to type (and didn’t).

  • mretondo

    I loved LightSpeed C, instant link times! I still have my LS C and Think C++ manuals.

  • Raj Madhuram

    I learned programming using Turbo Pascal 4.0. It was a big jump from 3.x if I remember right. It was a huge jump from the BASIC environments.

  • jg

    I use emacs.

  • jnavratil

    I was chastised by management for keystroking my own code on the 026 and 029 keypunches. Much easier to edit my work by holding the reader card to insert a character or hold the card being punched to remove a character. Remember that?

  • An_A_C

    I only wrote programs for computers requiring punchcards in college, that was at the tail end of punch card entry; terminals and line editors were showing themselves to be more efficient. As a student I had to be my own secretary. I just ejected the card and started over. I had to fill in a time slot in 9th grade and took typing, so I was ahead of my fellow programmers in that regard. Most useful class I took that year.

  • Lucas

    There will always be plenty of devs who don’t understand the unix shell. They will always do the most trivial engineering jobs and earn the lowest wages. They will always use IDEs, because they don’t know any better. The IDEs will always recycle the same half baked approaches to engineering. The articles like this will keep being written and immediately forgotten.

  • Ben

    Agree 100% on CodeWarrior being the best IDE I’ve ever used. I wrote GNU compiler/linker plug-ins for it that were *almost* usable. After Motorola (then Freescale) aquired them, the IDE went by the wayside. What a shame…

  • Kram

    VB launched in 1991 and is considered the first IDE? Please define “IDE”. Borland’s Turbo C 2.0 launched in 1989 with integrated debugger. And Turbo C++ 1.0 launched in 1990. I think you give Microsoft too much credit for the IDE. Microsoft has generally been a follower, not a leader, in these kinds of things.

  • goto 64

    Even good old Commodore 64 had an IDE in mid 80’s, called Turbo Assembler (not the same as the Borland tool) – integrated editor and assembler that could build, execute/test, and then enter again the editor. amazing that it is still updated to this day:

  • pick a name

    I toggled my programs in myself on the HP 2100A front panel switches – Not unlike the Altair kit.

  • Papasmile

    Does HyperCard count as a visual IDE 🙂 ?

  • Martin Sheridan

    In 1989, I worked for a company in Ireland/UK called Implementors. We were innovators in the market and our only competitor was IBM with a product called Sign-on. We developed a CASE tool on the PC that generated code, documentation and reports for the IBM Mid range S36/38 and AS/400. The GUI was ASCII based on a DOS machine and I build the drag-drop wysiwyg screen and report designers. I later re-designed/ported the toolset to Windows 3.1 using VB. I feel very proud to have been one of the early innovators in DOS based mouse-driven IDEs and Code Generation. I remember the ‘oooohs’ and ‘wows’ from our customers when we first demo the mouse driven interface – those were the days!