Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

Nowadays we have a lot of programming aids that make work easier, including:

  • IDEs

  • Debuggers (line by line, breakpoints, etc)

  • Ant scripts, etc for compiling

  • Sites like StackOverflow to help if you're stuck on a programming problem

20 years ago, none of these things were around. Which tools did people use to program, and how did they make do without these newer tools? I'm interested in learning more about how programming was done back then.

share

locked by World Engineer Jul 29 '13 at 14:00

This question exists because it has historical significance, but it is not considered a good, on-topic question for this site, so please do not use it as evidence that you can ask similar questions here. This question and its answers are frozen and cannot be changed. More info: help center.

closed as off topic by Walter, JohnFx, Macneil, Mark Trapp, LennyProgrammers Mar 16 '11 at 11:04

Questions on Programmers Stack Exchange are expected to relate to software development within the scope defined by the community. Consider editing the question or leaving comments for improvement if you believe the question can be reworded to fit within the scope. Read more about reopening questions here.If this question can be reworded to fit the rules in the help center, please edit the question.

29  
We certainly had IDEs and debuggers 20 years ago. In 1991 there was even an early version of Visual Studio. –  ChrisF Mar 15 '11 at 13:06
14  
Hammer and Chisel –  Matthew Whited Mar 15 '11 at 13:36
15  
Bah! You whipper-snappers, when I was young, all I had to make programs with were rocks and sand: xkcd.com/505 –  FrustratedWithFormsDesigner Mar 15 '11 at 13:59
16  
Bah, we couldn't even have zeros, we had to use the letter O. –  Loïc Wolff Mar 15 '11 at 14:25
15  
20 years ago you actually had to know stuff. There was no Internet that knew everything. –  Joel Etherton Mar 15 '11 at 14:28

37 Answers 37

up vote 31 down vote accepted

20 years ago, that's 1991. That's the year Borland C++ 2.0 IDE was released. With integrated debugger (with line by line and breakpoints), automated building using make.

It looked like this

You didn't have web sites like Stackoverflow, but with the IDE you were getting few thousand pages of documentation in nicely printed books.

share
3  
same way it works in IDEs today. You'd set breakpoints, the application being debugged would run, and on a breakpoint you'd see yourself back in the IDE. Only difference is that you of course couldn't flip between them in real time. –  jwenting Mar 16 '11 at 8:04

The first debugger was the guy gal who pulled the moth out of the vacuum tube ;)

share
1  
And it wasn't a guy...it was a gal... –  Jordan Mar 17 '11 at 8:15

In 1963 I was working at a summer job on campus. It was on the PDP-1 computer, made by Digital (DEC).

And yes, it had an interactive debugger, called DDT. You could set a breakpoint, examine and alter variables, patch code. The text editor was quite primitive, and we often used an offline paper tape machine instead.

The language was assembler. The machine had something like 4k of 18 bit words. No operating system.

By 1971, I was on a PDP-10 with 262,144 words of 36 bits each. An interactive timesharing system that supported maybe 10 concurrent users, a text editor called TECO, a debugger still called DDT, and languages like Lisp, Fortran, Basic, and Algol. TECO was really powerful. You could write text manipulating programs in it.

The PDP-10 was the basis for a similar machine made at Palo Alto Research, where the office of the future was born. Ethernet, the mouse and the GUI, e-mail, the laser printer, and object oriented programming. Palo Alto had all that. Ten years before the PC.

A lot of this stuff has been forgotten, and then reinvented several times in the years since then. And of course, there is a whole lot of new stuff as well.


Moving forward to 1991, I was working on a VAX. My primary language was SQL, although I wrote stuff in PASCAL when necessary. I also used DCL and Datatrieve as scripting languages, although we didn't use that term.

The VAX did not have an IDE at that time, at least not where I worked. But the text editor, the compilers, the linker, the debugger, and the command language were all built with the idea that the developer was going to use all of them. They worked together well. Remembering a handful of commands was no more difficult than remembering where a given tool is on a toolbar. Retyping the commands was made easier by command recall.

The VAX had an excellent debugger, but I never learned it. PASCAL made it pretty easy to get programs right to begin with, and structured programming made it pretty easy to localize a bug without using a debugger. Debugging SQL is a whole different ballgame.

In addition to working on the VAX, I used desktop tools to manipulate data locally. These were either MS Office tools or their precursors, I don't remember. The hard part was linking desktop tools to data stored in a database on the VAX.

share

1986: Z80 assembler, then i386 - Turbo Pascal and such. Wrote a program to beep Bach's prelude #1 for CP/M

1991: MVS/ESA Big iron - designing ISPF screens and Rexx procedures to do what ant/maven does today. Had plenty of debuggers. Eyeballed CICS dumps.

Used email to gopher files until I got a CompuServe account - good old days

share

20 Years ago I was working in C.

My IDE was vi (without syntax coloring).

My debugger was sprintf

My Ant was "Make"

share

20 years ago, I was part of a team using Interface Builder and Objective-C to create a desktop publishing app for the NeXTstep OS. And, yes, the internet was around, it was just a bit harder to use -- but I could find and post answers at comp.sys.next.

I was debugging debuggers at Sun in 1989 as a contract developer tech support person.

I was using IDEs nearly 30 years ago -- the UCSD p-System/Apple Pascal. Wrote Sundog: Frozen Legacy for the Apple II with Apple Pascal and 6502 assembly (1982-84). Wrote my own p-code/6502 disassembler, too. For that matter, I was using the UCSD p-System on a Northstar Horizon (Z-80) microcomputer at the Lunar & Planetary Institute back in 1981.

share

I started programming in 1981, coming up on 30 years ago this fall.

In 1991, I was working at Apple Computer (aka. just "Apple" these days), and was working closely with a small Canadian company by the name of Metrowerks.

Metrowerks was building a kick-ass IDE for C, C++, and Pascal. This environment played a major role in Apple's successful transition to the PowerPC processor from the 68K.

Even though I was an Apple employee, I was for several years effectively Metrowerks' Product Manager, working closely with Greg Galanos and Jean Belanger on product strategy, etc. It was this close partnership between Apple and a 3rd Party developer that enabled the Power Macintosh transition, Apple first great Mac transition (the second being the transition to OS X).

In 1981, I was entering my freshman year at UCSC and got the opportunity to start working on a Unix Release 7 (not Version 7) running on a PDP-11/70.

No IDEs here! Heck, we didn't have version control until a few years later!

It was vi (and vim wasn't a choice), cc, ln, and make. It was writing C Shell Scripts and hacking the source to C Shell to increase the size of environment variables form 512 character to 1024 characters, in order to accomodate the more and more complex TERMCAPS of our "smart terminals"

It was getting the opportunity to read a bootleg copy of the Lions Book on the floor of the off campus condo of an upper class CIS student, Ted Goldstein. Ted went onto a very full career including VP of Tools at Apple.

It was getting my hands on a Mac in 1984 and an early edition of MDS (Macintosh Development System) and learning to program this new and wonderful beast.

It was a lot of fun. It was much easier to get up and running. But the power we have with languages like Ruby is incredible. Instead of writing a hash table for my compilers symbol table, I am using them right and left as a basic data type!

Yes, it was a lot of fun, but I wouldn't go back...

share

The number one difference: a CD holds a lot less music than an iPod, so you took breaks a little more often -- once an hour (or so) you had to change to a different CD. Oh, and back then I used Sennheiser HD-420 headphones, but now I use HD-650's instead, which are almost amazingly better.

Second biggest difference: at that time I put in a lot of time customizing my editor to work exactly the way I wanted it to. I knew its macro language well enough to do a lot, and did so on a regular basis. Nowadays I just install Visual Assist-X, and call it good.

share

Are you kidding? I was rocking my 80286 in Turbo Pascal in the mid/late 80's.

enter image description here

share

20 years ago? I was using a nice IDE with a fantastic drag-and-drop UI builder and project manager. There was a pretty good OO language, a set of really good GUI objects, a bunch of great apps, and a terminal window that gave me a solid Unix shell. And a debugger, but I agree those are for the weak-minded (or dealing with their hideous code).

If that sounds kind of like the Mac, it's because I'm talking about the NeXT development environment, which is what turned into the modern Mac OS. For the whippersnappers, you can read the history here:

As a side note, I'll say that the awesome GUI-building there totally ruined me. When I went to start developing Swing apps in Java, it was like somebody's dog had eaten a stale GUI API doc and thrown it up again and Sun had shipped that. Thank goodness the web is finally getting somewhere.

share

The first computer that I programmed back in the seventies was a Univac 1218. The 1218 had a minimalist executive and 16K of 18-bit word-oriented ferrite core memory (hence, the term "core dump"). Secondary storage was handled via magnetic tape and Hollerith-encoded 80-column punch cards. The machine used one's complement for arithmetic and two's complement for addressing. It could be programmed and debugged using the front panel on which the contents of all of the registers where displayed using illuminated push-button switches. This CPU may seem primitive by modern standards, but it was very cool to me at the time.

Back on topic: I was using IDEs twenty years ago for most of my development. I am not one of those crusty old guys who believe that IDEs are for weak minds. A good IDE is a productivity amplifier.

share

I read this and thought wow that must be along time ago. Then I realized it is not a long time ago GRIN.

I was doing Clipper with the Norton Help. I really liked Clipper.

In my brain its not that long ago?

20 years ago were all those cool PC games. right after the spectrum/commodore/amiga age right after the TI 99 4/A :) (where I began programming in BASIC and EXTENDED BASIC)

This is not long ago ? Or am getting old?

share
1  
I'm to the point where I'm going to scan in all those magazines I can't part with. It's not the same as a real magazine, but PDFs take up a lot less physical space. –  oosterwal Mar 15 '11 at 22:22
1  
LOL I was thinking that too, I found however some nice archives such as ftp.worldofspectrum.org/pub/sinclair/magazines that save some work –  edelwater Mar 15 '11 at 22:28

Remotely from home in my dressing gown on a dumb terminal with 2400 baud acoustic modem to an HP Mini cluster. Upped the connection speed and got a Mac now but still got the same dressing gown.

share

Here's a standard form to help you write your FORTRAN programs before you screw up a bunch of punch cards.

enter image description here

(from: http://www.w3.org/2010/Talks/01-08-steven-ten-euro-computer/)

Be sure to use a pencil so that you can erase your mistakes, and leave a few blank lines between your printed statements in case you forget some steps.

(OK, maybe that's a little bit before 1991, but not by much...)

share

20 years ago I was coding on a 386 in Borland C++ using OWL for Windows programming.

My machine had a few MB of RAM and a 200MB hard drive. I could install most software from floppy disks - but more and more software was coming on CD.

When I pressed F8 to "Run" my project in Borland then the compiler would work quite quickly and I could instantly play with the results.

We had one PC in the office that every few hours would noisily connect to Demon (using Trumpet WinSock) and download everyone's email.

When we couldn't work out how to program something, then we often looked up the answer in a book - the Win32 API books were particularly useful.

Actually, we were quite productive... and the IDE's worked quite quickly back then! But they didn't have nice refactoring and nice integrated testing tools.

share

By now you should see that simple versions of most of the tools you're fond of were present in 1991, though unevenly distributed.

The more interesting comparisons are with 1981: the beginning of widely-available social processes involving USENET and UUCP and ARPANET networks. (The Internet's TCP flag day was in 1983.)

Even more interesting comparisons are with 1971: early versions of the operating systems you now know and love, social processes based on publishing (paper newsletters, conferences attended in person, sharing of code with personal contacts, user groups, using media such as magnetic tapes).

share
1  
Dear Jim Balter, We're not really disagreeing. I'm just emphasizing that the big difference between the 70s and the 80s was not the existence of tools, it was their truly widespread availability. Another case in point: See RFC923 (October 1984). Only 35 ASNs assigned then -- only a small fraction of universities. –  Liudvikas Bukys Mar 21 '11 at 17:55

20 years, eh? I was only operating in PC-land right at that particular time after having left Apple-land shortly before that. Back then I remember the rich kids had full-blown IDEs w/integrated debugging (Borland & Microsoft). The rest of us were scraping along with low-priced brands that worked fine, but were not so "integrated" (Mix Software, various shareware compiler vendors). Mouse was on the desk, but rarely touched. 90% of the time spent in text mode. Dual monitor setups were starting to fade away (earlier than that, it was common to have a monochrome coding monitor and a color "running" monitor in the same system as the MDA and CGA cards used different I/O/memory locations and could both be run at the same time in DOS). Early versions of Windows were not happy with multiple monitors. Most people had hard disks, but most work was still done on floppies for ease of transportation (except the rich kids that had Bernoulli drives).

Popular languages were C, Pascal, and Modula-2. People still used Logo and BASIC. "Visual BASIC" was finally starting to kill off BASIC though. COBOL and RPG were being taught in college.

Rich kids were using USEnet on the Internet, poor kids were still dialing into local BBS and using the FIDOnet groups (at 1200-2400bps usually, a 9600bps modem still wasn't affordable for most people, costing nearly as much as the rest of the computer).

share

I think the "web year" phenomenon has biased your date calculations.

20 years ago I was programming in Smalltalk - one of the first GUI based object oriented langauges on a Mac IIe with a 20 inch screen, so I think you have to go back a few more years than that to get the bear-skins and stone-knives era of programming.

Now 40 years ago I was programming in basic using a teletype terminal that had an acustic-coupler style modem (110 Baud baby!) - you know the kind that you dialed the phone, then stuck the hand set into the rubber cups on the modem.

share

I can speak for Bulgaria.

In contrast of you may think, Bulgaria was among the top countries for computer technologies. Being part of the communist block, USSR invested great amount of money in our computer science, making it a leader in the industry in the communist block. However communists did not tolerate private companies and everything in this area was managed by the government. Thus the recent collapse of the communist block few years ago left the country with no stable businesses to keep the industry in a good condition. However a nice legacy of knowledge left for the next generation of specialists. So we never stopped to have an access to the latest technologies and software development did not differ from the Western countries. We used the latest cutting edge tools and programming concepts.

Thus I won't repeat all that the others say, but yes there were quite good IDE's and debuggers at that time (corresponding to the nature of the software being developed back then).

I remember I personally used Turbo Pascal and Turbo C (by Borland). Also Autodesk's software for the graphics (like 3d Studio and Animator).

However the source for knowledge was more limited - mainly books, magazines, colleagues and rarely electronic magazines via BBS. Internet was mostly a curio. Some had access to Usenet, but rarely use it for work.

share

28 years ago I was writing assembly code in hex, by hand, for the 6809 processor (in the Dragon 32 for those of you who remember it) - I eventually wrote a mostly decent assembler for it, which helped.

There was no debugger - if it didn't work you'd add print code to have a look at the stack. Long nights! Efficient code helped, as there were fewer lines to go wrong

And nowadays I'm having to learn Clearcase, Maven, Ant and VS - all good fun (but I miss the old days)

share

In 1991, I used an IDE/Framework called UIMX on an X Terminal, creating Motif-based applications that accessed an Informatix RDBMS. Language was C.

There was SCCS for versioning, make for building.

Looking back, not that much different from how I work today.

share

More keyboard, less mouse.

share

20 years ago.

At home I was using a beige machine with an ARM cpu and a unique operating system with a nice windowing gui. It even had completely flat memory where you could trade screen resolution and font cache for program heap while a job was running. I think the company is now doing rather well.

At work I was using beige machines with a custom risc CPU and a BSD-unix operating system. The company is doing rather less well.

So many things have changed, I know have to do "ps -elf", when I used to do "ps -aux"

share

There were lots of great tools. How do think the Unix kernel was built? and compiled? and all the other huge apps like Lotus 123, Corel Draw, Wordperfect, Xenix, MS Windows, X Windows, gnu, Kings Quest, Flight Simulator etc

Unix had plenty of programmer productivity tools like lint for code analyzing, make for compiling and vi or emacs for editing. With the Korn shell (and probably others) you could suspend one editor and jump to another editor in 0.5 seconds, and do it on a slow dial-up modem with a greeen screen ("watching the grass grow"). You could debug with dbx or just read the core dump.

If you had the money for a graphics terminal you could use X Windows and xdbx for really fancy debugging.

The internet was there but not the WWW. We had anonymous FTP, gopher and WAIS. And the network news groups like comp.lang.c for posting questions (now it is mostly spam).

Those tools were powerful. Ever watch a kernel re-build run for a day or two? It would build makefile after makefile, building all those dependencies. And there was even pmake that could detect what targets could be built in parallel. Can ant do that yet?

On the PC there were the amazing Borland products like Turbo Pascal (v4 was a huge change when it came out in mid-80's).

Interesting times they were. And interesting prices. The Windows 3 SDK box had a carry handle but need two hands to lift, too many disks and 1 foot high stack of manuals. Relational databases cost thousands of dollars per user, Unix wars, spreadsheet wars over the slash key. I'm amazed at the tools I can get now for such crazy low prices/free.

The funniest part of all of this is that some of Visual Studio keystroke commands (CTRL-K + CTRL-C) are old Wordstar commands. A bit of nostalgia every time I use it.

share

Almost 20 years ago to the day I was using an IBM PC and an Amiga 1000 to cross compile C code and assembly for something called the Atari Lynx. The program in question ran 5 casino games in 47K (that's kilobytes) of space with 1K for some system variables. A whopping 16K was reserved for double buffer video. When the "development" system arrived, there were assembly language example routines to turn the screen one color and click the speaker. That was it. If you wanted text, well you had to make a font and your own text routines. Networking? Go ahead, just write your own drivers. Dunno why, but the difficulty of it was part of the fun. It's amazing any of it worked at all.

share

Only 20 years ago. You've got to be kidding. I was using debuggers in 1972 when I was learning programming. Admittedly the ones I was able to use were not as good as today. I suspect that they existed long before that.
The tools have changed over the years and they have gotten better, but don't even think that we didn't have tools back then.
I suspect that you'd need to go back to the 50's to get to the level where there were no debuggers.
The first really good debugger I used was on a VAX with VMS in the 80s. Everything has gone up from there.

share

20 years ago... 1991...

Let's see. I was using SunOS and VAX VMS.

We wrote code using text editors (vi or edit).

I -- personally -- don't use debuggers and never did. Some folks used the adb debugger on SunOS. I actually used it a few times to recover a stack traceback from a core dump file. I have no idea what was available on VAX VMS. I used print statements in the code.

We used make for compiling.

We read the paper documentation, thought and ran experiments. Indeed, that still works. Stack Overflow is overused by a few people who -- for inexplicable reasons -- refuse to run experiments or think.

30 years ago... 1981...

Let's see. I was using Univac Exec 8 and IBM OS.

We wrote code using text editors (I can't recall the Univac one, but the IBM one was the TSO environment's editor)

I -- personally -- don't use debuggers and never did. Those machines were "mainframes" and could not be single-stepped through anything. There was no "debugger". You had to insert print statements in your code.

We wrote scripts for compiling.

We read the paper documentation, thought and ran experiments.

40 years ago... 1971...

Let's see. I was using an IBM 1620 that had no OS.

We wrote code using punched paper cards.

Debugging meant single-stepping the processor. It was rarely helpful, so I learned to insert "print" statements in my code.

We run the compiler by hand to produce a deck of punched paper cards which we then ran. "by hand" meant literally loading cards into a card reader to install the compiler or assembler. Then loading the source code into a card reader to produce object code. Then loading the resulting object code into the card reader to run the program.

We read the paper documentation, thought and ran experiments.


"Get Off My Lawn You Rotten Kids"

  • IDEs. Almost useless. Code completion can be fun, but not as helpful as some folks claim. I've had folks tell me that VB is an acceptable language because of Visual Studio. Syntax coloring is perhaps the most useful feature ever invented. The rest should be optional add-ons, so we can dispense with them and free up memory and processor cycles.

    As crutches go, there are worse things to depend on.

  • Debuggers. Useless. Except when the language definition is so bad that the semantics are so murky that you cannot understand what was supposed to happen. For example, VB. When a debugger is necessary, it's really time to get a better language.

    Based on my experience teaching programming, debuggers can be unhelpful. For some people, they lead to clouded thinking and a weird empirical style of programming where there's no semantic significance to the code -- no meaning -- just pure hackery.

  • Ant scripts, etc for compiling. Incremental compilation and linking isn't really all that great an idea. With hyper-complex languages, it's a necessary hack, but really needs to be seen as a hack. It's not necessary or even desirable.

    A better language with less reliance on incremental compilation seems like a far, far better thing than sophisticated Ant scripts.

  • Sites like Stackoverflow to help if you're too stuck on a bug. Sometimes helpful.

    As with debuggers, there's a possibility that some folks will appear to be successful through simple blundering luck. That's a bad thing.

share
3  
Appox how many lines of code could you fit on 1 punch card? –  Click Upvote Mar 15 '11 at 13:32
38  
+1 for "Stack Overflow is overused by a few people who -- for inexplicable reasons -- refuse to run experiments or think" –  Binary Worrier Mar 15 '11 at 14:01
3  
@trufa in 1931 we had analog computers where the shape of wheels and gears modelled variables. In 1831 we had looms that read punched cards and the difference engine that ran spreadsheets and printed the results –  Martin Beckett Mar 15 '11 at 17:08
13  
Everything after "Get Off My Lawn You Rotten Kids" is a joke right? –  Alb Mar 15 '11 at 18:35
7  
I don't think that it is a joke. It seems "sad but true" –  Adam Arold Mar 15 '11 at 20:45

Goddamn kids. 1991? Really? What do you think was going on back then? I mean, Turbo Pascal was still kinda sexy, Netware was still a valid competitor to Windows, fast computers were still measured in mhz, but other than that, it wasn't too much different. Go back another 10 years, and you're talking green-screen stuff, but there were IDEs for those systems as well.

You have to go back to the mid-70s to find punch cards and crap like that.

share
1  
"wasn't too much different"? There was no web, and I'm sure that you too spend quite a bit of time every day pulling information necessary to do your work from the net. –  user1249 Mar 15 '11 at 20:12
4  
@Thorbjørn : We had the coffee pot cam! And usenet! What else do you really need? Honestly, from my recollections, it wasn't that much of a problem. The need for web documentation has increased with the complexity of the stuff you're creating. If you were hammering together an accounting application with a text gui, you didn't need much documentation. –  Satanicpuppy Mar 15 '11 at 21:02
1  
@satanicpuppy, you only had the coffee pot cam in 1991 if you were at Cambridge. Were you? –  user1249 Mar 15 '11 at 21:30
2  
"Netware was still a valid competitor to Windows" ... seems like you were living in an alternate universe in 1991. –  Slomojo Mar 16 '11 at 3:18
2  
@Thorbjørn usenet before the hordes descended upon it was a better resource than StackOverflow is today. Of course Wikipedia and the web in general is great, but programming isn't all that different. –  Jim Balter Mar 16 '11 at 10:24

20 years ago I was programming in BASIC. I did not have IDE because BASICA and GW BASIC are not IDEs. When I saw Quick BASIC later I was very happy. I was very excited when I first used Copy and Paste feature in development. Later they made QBASIC compiler not interpreter as it used to be and it was great too but then I moved to C and used Borland's Turbo C IDE. Note that I am in Egypt and back then there was no internet and we were about year behind in software. I mean if a version is released today, it will come to my hand about a year later. Now it's much easier but the joy of programming back then was incomparable :)

share
2  
+1, for bringing back fond memories of BASIC. –  MAK Mar 16 '11 at 6:55

20 years ago I was a student programming RMCOBOL-85.

I was using a green terminal connected to a file server.

The interface was a notepad style text editor. No fancy bits. We also had a choice of using VI. Never did though.

Ah good days. :)

share

Not the answer you're looking for? Browse other questions tagged or ask your own question.