Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

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.


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.

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
Hammer and Chisel – Matthew Whited Mar 15 '11 at 13:36
Bah! You whipper-snappers, when I was young, all I had to make programs with were rocks and sand: – FrustratedWithFormsDesigner Mar 15 '11 at 13:59
Bah, we couldn't even have zeros, we had to use the letter O. – Loïc Wolff Mar 15 '11 at 14:25
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.

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

Well it all started on punch cards, but I'm sure you've at least heard of that history lesson. That dates back to more than 20 years ago however.

For debugging? Lots of messageboxes, log files and other output methods to help check and see what just happened.

20 years ago 4GL's were all the rage.

Surprisingly, 20 years ago things weren't all that different. Now 30 years ago...

Now as I write this answer, keep in mind I was just 10 years old at that time, but still rocking 5.25" floppy disks into my 1 MB hard drive enabled IBM Headstart XT/AT PC. Why answer this question?

Because where I work, we maintain a 20 year old system and code base, so we're still in a time warp when working with the legacy systems, development environments and code.


Hmm, your premise is not quite true. The latter two items are correct, but 20 years ago we had IDEs and Debuggers.

In fact, debuggers have always existed. Their design and use has evolved since Brooks' team built the old IBM mainframes since we all have our own dedicated machines. However, now we can have the same debugger work for a number of different languages (see the GCC project, or MS Visual Studio for examples).

20 years ago, we didn't have ANT, but we definitely had Make. There were even a couple incompatible versions of the tool. That's what people used to build their projects.

And while the web wasn't readily available (it was still a research project in universities and the military), we did have books and magazines. The magazines provided the most up to date information and the books handled the theory.

We also had USENET, you can see archives of comp.lang.c and others on Google Groups, dating back to the early/mid 80s. – James Love Mar 15 '11 at 13:07
Check out this link: – Berin Loritsch Mar 15 '11 at 13:22
Debugging was invented in the EDSAC, in '48 or so. Gill, Wilkes, and their crew figured it out. Wilkes had an article in a computing history journal around '82 or so talking about it. If anyone is interested I should be able to dig up the citation. – Paul Nathan Mar 15 '11 at 15:51
A little over 20 years ago, I used the GeOS assembler: which compiled source code written in their word processor. It was a novelty to have WYSIWYG formatting for your comments, something I've never seen since. – Berin Loritsch Mar 15 '11 at 16:07
GDB: A debugger that sucks equally badly no matter what language it's attached to. It's a fundamentally bad architecture; the debugger needs to be tightly coupled to the language so it can understand and support language-specific concepts. – Mason Wheeler Mar 15 '11 at 16:17

20 years ago I was writing code in AMOS, which had an IDE and a pretty decent debugger.


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.

Appox how many lines of code could you fit on 1 punch card? – Click Upvote Mar 15 '11 at 13:32
+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
@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
Everything after "Get Off My Lawn You Rotten Kids" is a joke right? – Alb Mar 15 '11 at 18:35
I don't think that it is a joke. It seems "sad but true" – Adam Arold Mar 15 '11 at 20:45

20 years ago we had Borland Turbo Pascal and Turbo C++, pretty potent IDEs with integrated debuggers, profilers, etc.


Thanks for making a guy feel old :-)

Debuggers and makefiles were around back then. Compilers either came with thick books, or for Unix, a large set of man pages. Most Unix developers used vi or emacs. I didn't do any desktop programming back then, but I'm pretty sure they used editors that came with the compiler that were essentially IDEs with fewer features. You got help from colleagues, books, or magazines.


20 years ago, I was programming in GFA Basic on an Atari ST 1040:

atari st 1040

Lucky you. I had Atari ST 512 at that time – Nemanja Trifunovic Mar 15 '11 at 17:18

20 years ago I was coding, mainly in C, Pascal. For DOS platform there was Turbo C, Turbo Pascal that were mostly complete editors with debuggers allowing step through. For real programming, I feel most programmers like myself used vi + compiler, run from command prompts.

Programming was little harder back then, especially for some programming languages. I can still see traces of this in my own programming: I find running my tests with print statements easier than stepping through statements.


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. :)


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 :)

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

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.


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.


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.

"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
@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
@satanicpuppy, you only had the coffee pot cam in 1991 if you were at Cambridge. Were you? – user1249 Mar 15 '11 at 21:30
"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
@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

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.


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.


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"


More keyboard, less mouse.


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)


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


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.


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.


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).


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).

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

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

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

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.


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.


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


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...)


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.


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?

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
LOL I was thinking that too, I found however some nice archives such as that save some work – edelwater Mar 15 '11 at 22:28

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