Slashdot Mirror
The History of Visual Development Environments
Esther Schindler writes "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 as Andy Patrizio revisits the evolution and impact of the visual development metaphor. '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.' Where do you start? 'While TurboPascal launched the idea of an integrated development environment, [Jeff] Duntemann credits Microsoft's Visual Basic (VB), launched in 1991, with being the first real IDE.'... And yes, there's plenty more." A comment attached to the story lists two IDEs that preceded VB; can you name others?
Making managers that are "handy" think they are programmers cince 1992...
Do not look at laser with remaining good eye.
Had a block-graphics GUI, mouse support and a visual debugger
Can't remember the date, but certainly pre Windows 3.1
QuickBasic was already at v4.5 in 1988 - 3 years before Visual Basic.
That's a very Microsoft-centric article, although it does have a passing mention of Smalltalk. Earliest IDE I ever used was the toolset on VMS, which included editor, compiler, debugger and profiler - they were integrated via the shell. If that doesn't qualify, then there was DevPac for assembler and a C development package (Lattice C I think) on my Atari ST, which inclued integrated tools that were far more sophisticated than what was later offered by Turbo Pascal.
"There was a time when programs were written in text editors."
Yeah , 5 minutes ago when I finished updating some code.
Plenty of unix C/C++/script/python coders still use vi and emacs. Just because IDEs rule the roost in Windows and Java development, don't assume every coder users or even requires them.
Personally I consider smalltalk the mother of the IDE (and GUI as well). Nothing has surpassed it yet....
I remember ObjectVision as an interesting example of visual programming by configuring blocks. Unfortunately it was very limited, and one reached the boundaries quite fast. IBM VisualAge is another story. I cannot remember a more complete, truer IDE than this. I used it mainly in Smalltalk and Java, but other versions for C/C++, Basic, and even COBOL existed. But it really shined in Smalltalk, it native environment. VisualAge allowed to put the pieces of a program together graphically, autogenerate code, switch to code and extend it programatically, keep version control of every time you push save, debug in place.... it was an amazing product. I am glad many features where migrated to Eclipse, but I miss the overall experience of putting a visual prototype together in one afternoon.
VB was created by a company named Tripod and later purchased by MS.
Goodbye Slashdot. You've changed.
When I think of "visual programming" the first thing I think of is Hypercard ... I was at uni when that came out, so late 80's?
"Flame away, I wear asbestos underwear"
EMACS on the DEC 10s/20s was able to do context sensitive editing, build and debug (DDT invocation) all within the app. This was in the 70s and early 80s.
I used it for C and Macro Assembler all the time and while most people think that EMACS was just an editor, its scripting capabilities made it very, very unique in its abilities to handle integration. The DECUS tapes were full of examples from folks all over the world who did some amazing things with development tools, all before the "open source" and "free software" concepts came into being.
Harrison's Postulate - "For every action there is an equal and opposite criticism"
all the gory details here:
http://www.folklore.org/StoryView.py?story=MacBasic.txt
A later development was Borland's ObjectVision --- there was even provision for loading ObjectVision files into other more sophisticated Borland environments if memory serves.
NeXTstep of course had Interface Builder and Project Builder around that time as well.
William
Sphinx of black quartz, judge my vow.
The thing about an IDE is that it's an obvious concept and pretty much anyone who's tried to make programming more user friendly has implemented such a thing. True, NetBeans looks nothing like the ZX80 or EMACS, but then Java in 2013 looks nothing like ZX BASIC either - as languages have evolved and projects have become more complex, the tools to manage them have needed to become more complex and manage more concepts.
What's funny is that we bothered giving the concept a name at an arbitrary cut-off point in the development of development environments.
You are not alone. This is not normal. None of this is normal.
Yes, Unix. Unix is an integrated development environment.
Back in the late 80's early 90's my favourite IDE was actually AutoCad plus and external compiler being used to program a Bailey Network 90 Distributed Control System (mentioned deep in Distributed Control Systems).
You drew up the process control drawings in AutoCad and visually connected data signals from processing block to processing block and when finished you pushed the AutoCad drawings through the compiler (which on the Compaq 286 we had took all night for the job I was working on) . This produced the executable code that you then downloaded to the controllers. It was the best example of self documenting code that I have seen as the AutoCad drawings were always up to date.
It was a pity that the application software libraries on the controllers themselves were so bug ridden, but otherwise it was a great system. Except for the controllers running standard MS Basic on 68K? boards (which was good), while the operator stations ran TI Basic on a TI/99 board (which was bad) - and also used 8 inch floppies for storage.
I am Slashdot. Are you Slashdot as well?
Is this article about GIDE or IDE? VB was definitely not the first IDE. Hell it wasn't even the first GIDE. We were using National Instruments LabVIEW a couple of years before VB. Of course it was instrument control specific but ran on a MAC or a PC.
"A person is smart. People are dumb, panicky dangerous animals and you know it." - K
Back in the day I used MS C/C++ 5.1 (one of their finer products IMHO). This was classical command line suite with compiler, linker, make and a nice editor (called me I think).
Based on an idea in .EXE magazine I wrote a special make file and a batch script that:
1) Run the special make file to generate a new temp batch script to compile the code (only one file) as needed
2) Ran the new temp batch file
3) Saved the error report if present
4) If the error report was present then parse the errors and source code to the editor for correction
5) Jump to step 1 until all files were made
It was so bloody arcane so that as little was running in memory at one. It was either make, the compiler or the editor using the precious 640K at at time. But it certainly felt a lit faster in the compile/edit/cycle once I got it working.
"I don't know anyone who just uses vi anymore either. Most use vim"
I think its fair to say that "vi" and "vim" are interchangable names these days and have been for about a decade.
Which makes him a retard. Form designers are not the primary component of IDEs, nor are they necessary to be called an IDE.
While not on the same hardware as the x86 pcs, both Symbolics (owned the first .com domain) and Lisp Machines International had IDEs on their custom hardware platform's Lisp machines. The genesis of both of these was from the work that originated at MIT in the early 1980s.
Arguably these may be considered a predecessor to visual development environments but HP workstations starting in the 1970s had integrated editing and compiling including fairly sophisticated graphics and built-in IO support for the entire range of HP peripherals from disks, printers and plotters to HP instruments. HP started with a proprietary language, HPL, but they also supported a BASIC dialect in the 80 series and a super-fast Pascal development environment in the 200 series. These systems were not cheap but they were amazingly capable.
http://www.hpmuseum.net/
Integrated compilation and code editing, and integrated debugging.
Come on, have all of you forgotten Forth? You could have integrated *incremental* compilation, code editing, and debugging on the first IBM PCs just fine, including support for multi-tasking, virtual memory, graphics, integrated assembly for optimizing critical code, and whatnot. In fact, people had all this on 8-bit machines before that!
Ezekiel 23:20
I would like a visual studio style ide for linux if I could get one.
I sometimes joke about a perverted hack where you would run Visual Studio inside Wine (modern versions of VS currently don't run) and somehow modify the tool chain settings to produce Linux binaries (MinGW?).
Anyway, how about QT Creator or KDevelop? They work great for non-qt work too.
Do you still remember RHIDE? It was usually combined with DJGPP (C/C++ build tools for DOS). RHIDE was nifty and easy to use.
What I'd like to try out, and this does sound a bit silly, but some minimalist IDE for the Modern UI. I tried browsing the Windows Store but there wasn't much coding stuff available at all.
I used Turbo C for a few years starting with version 1.5 in 1988. It was a sweet product, with one-button building and test runs plus an integrated debugger, and it was incredibly fast for the time. The editor was kind of primitive compared to vi, but usable (basic insert/delete/arrow key stuff).
I eventually switched over to Zortech C++ to get extended memory support. That was an impressive product also, and apparently all developed by one programmer. It eventually became the Symantech product mentioned in the article.
Nowadays my Windows development work is split between Visual Studio and vi/make. I still prefer the latter for anything that's algorithmically complex.
Have you read my blog lately?
Without even trying to do any historic digging:
Asymetrix Toolbook shipped "with" Windows well before VB. In fact the company I worked for foolishly assumed it was "part of" Windows. Toolbook, in turn, was not exactly a knockoff of HyperCard, but was certainly a member of the same genre.
LabView for the Macintosh shipped in 1986, and not only still exists but has a very solid niche in some circles. LabView is such a pure visual IDE that there are not visible lines of code as such; it is all wiring diagrams.
Bill Budge's 1983 Pinball Construction Set, for the Apple ][ and Atari, was certainly an IDE, although for a restricted class of applications.
Incidentally, it seems to me that the later incarnations of Visual Studio are considerably less "integrated" than the original Visual Basic was. Visual Studio has the feeling to me of being no more "integrated" than, say, Borland C++ or the (1985) MacPascal. Unlike VB, it just had a fairly crude resource-editor-like "drawing" environment. It feels OK when you're creating things for the first time, but the visual objects do not really "contain" code--they have a very loose and fragile connection to the code associated with them.
"How to Do Nothing," kids activities, back in print!
Borland's early Turbo compilers were amazing (fit on two floppies, and fast). They used a DOS-based windowing system called Turbo Vision. Your app ended up looking like the Turbo IDE, with windows, drop down menus, checkboxes, etc., instead of the Windows 3.1 API. Indeed you could draw color graphics and animate math functions, etc., though that may have been in some kind of full screen mode.
Borland went over to the Windows API soon after all that. It all went to heck for Borland C++ when they dropped the Turbo name in the mid 1990s. Just too buggy to run (version 5). But Borland's Delphi Pascal stayed strong, and I use a text editor written in Delphi to this day. There were lots of user-contributed components, for instance, to make internet protocols work! Microsoft wasn't the only company that missed the boat on TCP/IP. Borland, like MS, put much of its effort into desktop database libraries instead.
gvim is one of my most-used tools as well. From my experience, an IDE is only beneficial for large projects with complicated build or deployment procedures with more than a couple developers. Languages like Java, and to some extent C++, also tend to encourage their use, especially as your external dependencies increase. C really encourages you to keep things small and manageable, so I've never felt like I've needed an IDE to keep my head wrapped around a C project. Python's sort of the same way, but at least partially because the language is so simple that it becomes much easier to keep it well-managed. For larger Javascript projects, even if they get big and awkward, there are no build procedures to speak of so just using a more robust editor like Sublime Text 2 is sufficient for me.
Apparently wizard is not a legitimate career path, so I chose programmer instead.
It really annoys me when people say vi instead of vim. It probably has something to do with “vi” often being an alias to vim on many systems.
Seriously, a couple weeks ago there was an article warning us all of the coming Unix Epoch doom, and today we are learning about a magical time when programs were written with editors! I understand that Dice.com as a job board is used to serving the lowest common denominator when it comes to IT and software "professionals," but give me a break.
Apparently wizard is not a legitimate career path, so I chose programmer instead.
Why is the summary talking of this as if it were the past? Of course programs are still written in text editors.
Few people use IDEs, since they have scalability problems and usually interact badly with complex toolchains or build systems...
But if you were to use an IDE, Visual Studio is definitely a bad idea. On top of only working with a very sub-par compiler, it's also terribly slow and inflexible.
I know Jeff Duntemann is quoted as saying âoeThe PC culture was inherited from the IBM mainframe world. The graphics in that era werenâ(TM)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" That's just a dumb thing to say. It's like saying "back then turbo charged engines in commercial cars still had a foot in the racing world!" Doh!
The 1975 article (in German):
http://www.computerwoche.de/a/interaktives-programmieren-als-systems-schlager,1205421
Google Translate:
"New to PET is the online resource management deck with a kind of list management. The next step of development is certainly the effect that the list is no longer printed, but will be converted so that only one error list is written - so you can watch the program.
Pioneering is the interactive programming."
I used to use a FORTRAN77 IDE in PC-XT back in 1983. It had an integrated editor, compiler, step through debugger. It supported all the ASCII escape character codes to move the cursor on the screen of a EGA display (640 x 480). I wrote a cross-word puzzle grid generator in fortran using it. Move the cursor, click to toggle squares to black/white, with automatic symmetry squares kept in synch. Some minor snow flake simulation, and a Laplace equation solver using finite differences, and a 2D contour plot program. Pretty nice and powerful, for something that runs on a PC-XT.
sed -e 's/Chuck Norris/Rajnikant/g' joke > fact
Read the Graham quote, and there at the end - "How can you get anything done in them, I think, without macros?" is probably something that people without Lisp experience are not going to grok just because there are other languages that have a thing called 'macros'. And then I look in the link (having not read that article in a while) and find Graham explaining the difference.
It kind of reinforces the point of the portion you quoted, the way you quoted it, leaving out the further explanation of what Lisp macros are. If you already know, you'll get it immediately - if you don't, you might well sit there and say 'But ... C has macros! C++ has macros!' and miss it completely.
Quite true; it was already getting to be a longish post. :-)
For the readers who may not know much about Lisp here are the next few sections: Graham's original essay is worth a read. http://www.paulgraham.com/avg.html. Quite thought provoking.
Any way, here's the bit on macros:
Many languages have something called a macro. But Lisp macros are unique. And believe it or not, what they do is related to the parentheses. The designers of Lisp didn't put all those parentheses in the language just to be different. To the Blub programmer, Lisp code looks weird. But those parentheses are there for a reason. They are the outward evidence of a fundamental difference between Lisp and other languages.
Lisp code is made out of Lisp data objects. And not in the trivial sense that the source files contain characters, and strings are one of the data types supported by the language. Lisp code, after it's read by the parser, is made of data structures that you can traverse.
If you understand how compilers work, what's really going on is not so much that Lisp has a strange syntax as that Lisp has no syntax. You write programs in the parse trees that get generated within the compiler when other languages are parsed. But these parse trees are fully accessible to your programs. You can write programs that manipulate them. In Lisp, these programs are called macros. They are programs that write programs.
I used Suntools to create windowed apps on their workstations in about 1988... the first bunch were done by handcoding the panels, then someone came out with 'Tooltool' - and that basically did what most of the current form-creator GUIs do.
Less is more.
I would say Turbo Pascal and co where by far not the first integrated development environments and also not the first graphical IDEs.
Heck, I guess in the LISP world the development likely was also done with an IDE, may it have been graphical or not.
I can not immagine a Symbolics machine having ny a text editor.
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
The LISA 6502 assembler had an integrated IDE on the Apple II. It did syntax checking and some code generation in real time, doing something useful with all those CPU cycles as it sat there waiting for you to type.
Xerox Pilot/Mesa. Ran this on Xerox 8010 in the early '80s. Simple version on Alto in the 1979. WIMP interface standard.
"I don't know anyone who just uses vi anymore either. Most use vim"
I think its fair to say that "vi" and "vim" are interchangable names these days and have been for about a decade.
I use vi, but I don't use vim. Not for longer editing sessions, but when I'm root, or logged into some small embedded system. I also use the vi which comes with Solaris (the one that will refuse to start if your terminal is too wide) because noone has bothered to install a decent editor on those machines.
What a load of horsecrap. Missed entire platforms.
This is a company that makes an "IDE" that is all about Web apps, and then selling it as a "write once, deploy everywhere" snake oil solution. One tool->hammer all problems->nails.
It's a comment/click magnet, and it's just been slashdotted.
Not *one* mention of the best programmer's editor, Brief, that was used all over in the late eighties/well into the nineties?
Hmmm, maybe now it'll run under wine....
mark
Delphi is now C++ builder, which IIRC is now also renamed.
Object Pascal was just a different dialect of C++. Not better in any way I could see, just different to be different.
The one thing VB could do back in the day (being an interpreted language). Edit and continue. I still don't know any IDEs that allow it. Compiled languages make it out of the question.
I've seen a few good uses of multiple inheritance. Buy functionality. Inherit it into your object. Just be very careful, use rarely and thoughtfully and after considering the options, multi-inheritance can make huge confused messes. If you control all the code but one parent, multi-inheritence is likely a bad idea. Stack them up.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
I'm not a big fan of vim myself. Sure it's customizable but I never do anything in it other than what basic pre-vim vi did.
People say "vi" because they really mean the vi key bindings and work style, not a particular product. Vim is just one of many vi clones.
MPW
ParcPlace (?) Smalltalk
Lightspeed/Think C
Hypercard
I did a project or two on Mac Common LISP, but I don't even remember whether that was an IDE or not. It's been a looooong time.
Even earlier than that, I used some Pascal dev environment on the TRS-80, but I don't think you could call it an IDE. Not much room for integration in 48K.
What do code wizards have to do with debugging? I thought they were for coding, and my experience with them has been rather unpleasant.
Some years ago, a Windows/COM expert showed me how to add a method to an interface using a Visual C++ wizard. We went into a labyrinth of dialog boxes, setting properties and meticulously adding each and every parameter and type. At the end, I ran cvs diff to find it had added one line to the program:
virtual HRESULT STDMETHODCALLTYPE GetSensorStatus(BSTR device, ARGOUT BSTR *status, ARGOUT long *result) = 0;
We then had to run a different wizard to add a corresponding method to a subclass. After all that, we ended up with three copies of the interface. Oh! And, they had to be in the same order, because whereas DLL COM uses ordinary name linkage, interprocess COM uses numbers to identify methods. I eventually boiled down the number of copies to two.
The LabVIEW programming language had a full visual editor for its dataflow syntax in 1986. Mac only. Wasn't on Windows until 1992, but as an IDE it does predate the VB date in TFA.
The one thing VB could do back in the day (being an interpreted language). Edit and continue. I still don't know any IDEs that allow it. Compiled languages make it out of the question.
Visual Studio had Edit and Continue for C++ for at least a decade.
'While TurboPascal launched the idea of an integrated development environment, [Jeff] Duntemann credits Microsoft's Visual Basic (VB), launched in 1991, with being the first real IDE'.
"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".
AccountKiller
an IDE is only beneficial for large projects with complicated build or deployment procedures with more than a couple developers.
Well, there must be other constraints to the projects you experienced. NetBSD has a source repository of more than 6 millions LoC, more than 200 developers scattered worldwide, it targets 16 CPU types. And nobody use an IDE when dealing with it.
Except that it's not a dialect of C++. Object Pascal is a dialect of Pascal, which was a descendant of ALGOL W which was a variant of ALGOL 60.
C++ traces it's roots to C, which comes from B which was based on BCPL which came from CPL which was inspired from ALGOL 60.
So while you're right in a way, in that both are descendants from ALGOL 60, the languages are otherwise not related.
/ The Arrow
"How lovely you are. So lovely in my straightjacket..." - Nny
...as a link generator.
Welcome to the world of the Twenty-First Century viral marketing campaign.
When the article appeared on the FP of this site, I'll bet that the Mendix folks popped a Dom Perignon bottle.
We've been punk'd.
"For every complex problem there is an answer that is clear, simple, and wrong."
-H. L. Mencken
Note that the Clarion development system had a decent IDE even back in DOS. And it's still better than M$, I think.
I like this reply, from the link:
" FF222 a day ago
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."
I was never a programmer myself, but I once tried out and was impressed by Borland's C++ Builder and JBuilder. Anyone ever tried it?
When? It never worked that way for me. Edit, and continue running the old code yes.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
They come back together in a weird way.
Every C++ operator had an object pascal equivalent. The syntax was similar enough you could write a translator. Granting the object libraries were different.
IIRC object pascal even had it's own templates.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
In pre .net VB you could edit the source code in the debug window and continue executing the code, including the new changes.
The one good example of multi inheritance I've seen was a object persistence library. Rather then inheriting from persistent object you inherited from object and persistent (persistent required you to overload the streaming operators so the library could store/retrieve the objects). This allowed you to use any type of object with persistent. Persistent did violate a basic rule. It did clever things. (overloading constructors, destructors, pointer resolution, deleting objects from memory without asking, leaving you with a stub that it would flesh out again if you actually needed it)
Basically I'll use multi inheritance if I need to buy two sets of functionality and they can be made to work together. I'll never use it on my own code.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
There aren't that many attempts at completely getting rid of the textual representation in programming. One of them is Intentional Programming (http://www.intentsoft.com). See this demo from 2006 for example: http://www.youtube.com/watch?v=tSnnfUj1XCQ. I think it's fair to say it didn't really take the world by storm. Unfortunately?
-- Did you try Tao3D? http://tao3d.sourceforge.net
I've always been quite puzzled about the use of "Visual" or "Graphical" for this kind of "mostly text with some rectangles thrown-in for good measure" IDEs. Besides being bit-mapped, there's nothing really graphical about them.
Want something visual? Try this: http://www.youtube.com/watch?v=apy5csu0DkE. Or this: http://www.youtube.com/watch?v=paJG7Fy5Few. Or this: http://www.youtube.com/watch?v=m4a0jcrDgK0. Or the amazing stuff on this page: http://www.iquilezles.org/live/index.htm. Now, that's visual ;-)
-- Did you try Tao3D? http://tao3d.sourceforge.net
As I said, for at least a decade. Edit and continue running using the new code.
There are only certain type of change that you can make. For example you can't change the size or number of member variables of a class. But still it's there for some other changes you can make, such as adding or deleting lines of code.