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.

  • 29
    We certainly had IDEs and debuggers 20 years ago. In 1991 there was even an early version of Visual Studio.
    – ChrisF
    Commented Mar 15, 2011 at 13:06
  • 14
    Hammer and Chisel Commented Mar 15, 2011 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 Commented Mar 15, 2011 at 13:59
  • 16
    Bah, we couldn't even have zeros, we had to use the letter O. Commented Mar 15, 2011 at 14:25
  • 15
    20 years ago you actually had to know stuff. There was no Internet that knew everything. Commented Mar 15, 2011 at 14:28

37 Answers 37


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 http://www.ee.oulu.fi/research/tklab/courses/521419A/tc201_compile.png

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

  • I learnt to use TC and TP IDE (s) in school, altought I heard there where similar tools, these cheap tools brought the I.D.E. to mainstream programming...
    – umlcat
    Commented Mar 15, 2011 at 18:16
  • Fancy Schmancy Gizmos. You wouldn't need them if you used butterfiles. Commented Mar 15, 2011 at 23:18
  • Good old Borland... if your app was too large you had to pick and choose the DLLs that you compiled with debug code or you'd crash the whole machine.
    – MadMurf
    Commented Mar 16, 2011 at 0:23
  • I remember those books with the small three-whole punched paper in what amounted to a small binder.
    – JohnFx
    Commented Mar 16, 2011 at 0:55
  • 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
    Commented Mar 16, 2011 at 8:04

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.

  • 3
    Appox how many lines of code could you fit on 1 punch card? Commented Mar 15, 2011 at 13:32
  • 38
    +1 for "Stack Overflow is overused by a few people who -- for inexplicable reasons -- refuse to run experiments or think" Commented Mar 15, 2011 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 Commented Mar 15, 2011 at 17:08
  • 13
    Everything after "Get Off My Lawn You Rotten Kids" is a joke right?
    – Alb
    Commented Mar 15, 2011 at 18:35
  • 7
    I don't think that it is a joke. It seems "sad but true"
    – Adam Arold
    Commented Mar 15, 2011 at 20:45

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.

  • 17
    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
    Commented Mar 15, 2011 at 13:07
  • 1
    Check out this link: en.wikipedia.org/wiki/Integrated_development_environment Commented Mar 15, 2011 at 13:22
  • 3
    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. Commented Mar 15, 2011 at 15:51
  • 1
    A little over 20 years ago, I used the GeOS assembler: en.wikipedia.org/wiki/GEOS_%288-bit_operating_system%29 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. Commented Mar 15, 2011 at 16:07
  • 4
    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. Commented Mar 15, 2011 at 16:17

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.

  • 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
    Commented Mar 15, 2011 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. Commented Mar 15, 2011 at 21:02
  • 1
    @satanicpuppy, you only had the coffee pot cam in 1991 if you were at Cambridge. Were you?
    – user1249
    Commented Mar 15, 2011 at 21:30
  • 2
    "Netware was still a valid competitor to Windows" ... seems like you were living in an alternate universe in 1991.
    – ocodo
    Commented Mar 16, 2011 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
    Commented Mar 16, 2011 at 10:24

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

  • Borland C++ was pretty sweet at the time. Commented Mar 15, 2011 at 16:25

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.

  • Arrrrggghhhhhhh, you mentioned Wordstar!
    – HLGEM
    Commented Mar 15, 2011 at 14:13
  • Unix was written with ed -- none of the tools you mention existed at the time. We had the Mashey shell, which was succeeded by the Bourne shell -- the Korn shell was a late arrival.
    – Jim Balter
    Commented Mar 16, 2011 at 10:31

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

atari st 1040

  • 2
    Lucky you. I had Atari ST 512 at that time Commented Mar 15, 2011 at 17:18
  • Oooops. I mean Atari 520. It had 512 Kb of RAM :) Commented Mar 16, 2011 at 2:29

More keyboard, less mouse.


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.

  • I'd like to apologize to everyone for still using makefiles and emacs.
    – bev
    Commented Mar 16, 2011 at 4:58
  • @bev You are not the only one :)
    – user25446
    Commented Mar 5, 2012 at 9:13

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


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.

  • "110 Baud baby" LOL
    – edelwater
    Commented Mar 15, 2011 at 22:55

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


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.

  • I remember keypunch card's in the 1980's.
    – crosenblum
    Commented Mar 15, 2011 at 13:34
  • Goddamn 4gls. I used one (Speedware) YESTERDAY. Why anyone ever thought that was a good idea is beyond me, but all my predecessors put untold man-hours into coding unsupportable 4GL code, and every now and again, I have to tweak something in the system. Talk about a useless skill. Commented Mar 15, 2011 at 14:51
  • @Satanicpuppy: 4GLs were the web frameworks of the day. I can just imagine what devs 20 years from now will be saying about Ruby on Rails/jQuery/Zend code: "Who ever thought this was a good idea? Was everyone at the turn of the century a moron?" :)
    – TMN
    Commented Mar 15, 2011 at 15:50
  • @tmn: Heh. I don't like those either, for pretty much the same reason...Of course, I don't need to use them either, not being a web guy. 4GLs were worse though, because they were proprietary. Support cost a fortune, and if you didn't have support, you couldn't upgrade. I looked into a new license for ours a few years back, so I could migrate everything to a new server environment, and the license ran 150k! Per site! The COBOL I could migrate for free, and the databases only required some $500 interface. Whole project shut down because of that goddamn proprietary 4GL environment. Commented Mar 15, 2011 at 16:00
  • Now 4GL there was a thing to remember. Commented Mar 16, 2011 at 2:01

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.

  • I still use vi (gvim) together with Visual Studio (I used it today). I use VS only for code completion (it looks up methods for me) and for starting IncrediBuild. Otherwise I can edit much faster using vim.
    – Giorgio
    Commented Apr 24, 2012 at 19:13

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.

  • There were definitely fewer sources of knowledge twenty years, but the quality of the average software practitioner was higher. Twenty years ago, only the most determined survived in this industry. Now, incompetence can hide behind good "Googling" and cut-and-paste skills. Commented Mar 15, 2011 at 20:07
  • What kind of software did you make in Bulgaria back in those days if there were no private companies? Commented Mar 16, 2011 at 3:15
  • @Click Upvote Scientific, military, space, engineering, etc -- everything funded by the state itself, obviously -- or at least it was that way in my country (USSR) back then.
    – mlvljr
    Commented May 3, 2011 at 10:04

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.


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

  • The ARPANET was up and running in October 1969 -- I was there for the first login. We were soon sending e-mail, though the '@' wasn't "invented" until a couple of years later. But even before then we had interuser messaging on time-sharing systems -- the real beginning of things like usenet.
    – Jim Balter
    Commented Mar 16, 2011 at 10:40
  • Yes, in the 1970s, the "in crowd" (relatively few) had ARPANET, Xerox Altos, Ethernet, Dover printers, wrote programs in Smalltalk, Lisp, Simula67, or C, and had Tenex and Unix for OSes. In the 1980s, <i>everybody</i> had wide-area networks, and remote colleagues sharing larger and larger bodies of code. Commented Mar 16, 2011 at 21:19
  • These things were common in universities.
    – Jim Balter
    Commented Mar 17, 2011 at 3:39
  • 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. Commented Mar 21, 2011 at 17:55

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.


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.


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

  • Wow! And no RSI or carpal or any other health setbacks from all those years of programming? No, dont get me wrong, I dont mean to say 20+ or 30+ years of coding leads to RSI, but I have seen cases where too much use of the editors like vi led to that eventually.
    – Mamta D
    Commented Mar 16, 2011 at 5:22

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

  • Yay, me too! An interesting combination of terrible and fantastic language to learn to program in, but it worked out pretty well in the end. I used STOS, its Atari ST predecessor, before that.
    – Liedman
    Commented Mar 15, 2011 at 19:19

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.


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)


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


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


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.


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

enter image description here


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.

  • Way cool to hear this Bruce! I remember when you left the world of Mac to work on NeXT....
    – Jordan
    Commented Mar 17, 2011 at 8:17

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.

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