I heard that some very very early versions of C compilers for personal computers (I guess it's around 1980) resided on two or three floppy disks and so in order to compile a program one had to first insert the disk with "first pass", run the "first pass", then change to the disk with "second pass", run that, then do the same for the "third pass". Each pass ran for dozens of minutes so the developer lost lots of time in case of even a typo.

Well the thing about waiting a day was not so much the run time of the job, it was the queue of stuff in front. There used to be places you would go to submit your card deck and some nazi in a white coat would take it away and put the cards in the hopper at their leisure. The run time might only be a few minutes or seconds. The human processing time was often in hours.
–
quickly_nowFeb 25 '11 at 2:11

4

I've seen modern day C++ projects that a full clean and rebuild takes dozens of minutes, and instead of disc swaps it's doing virtual memory pages automatically via the OS. Why does everyone keep saying computers are so advanced these days? =)
–
Patrick HughesMay 15 '12 at 18:34

13 Answers
13

Absolutely. I had Microsoft C (version 1.0, I think) for a Zenith Z100 computer in the early 80s that was delivered on several 5.25" 360K floppy disks. The Z100 didn't have a hard disk so I had to frequently swap floppies as I switched between the editor, compiler, and linker. Compile and link times of several minutes were not unusual. It got to be so annoying I paid $500 for a 2MB (yes, megabyte) memory expansion board so I could load all of the files into a RAM disk. That cut the time down to about 30 seconds. Funny ... I actually enjoyed programming back in those days because it was fun. Today it's work.

In the early days of home computing (for the kids/parents not the Hobiest) machines did not even have hard drives.

My parents had an Amstrad the OS was on 1 floppy and it allowed you to select the application to run which may have required switching floppy disks (ie the word processors was on another disk) requiring a manual switch back to the OS disk if the application needed some specialized OS service.

I had a copy of pascal for the amstrad. I remember the editor being on 1 disk but during compilation it required switching back and forward between disk1 and disk2 as the compilation processes continued (it may even have required a switch to the OS disk at certain points in the processes (but that I am not so sure off)).

A the good old days when the whole OS fitted on a single 3.5 floppy disk (but not much else).

Floppy disks were introduced in 1971 - (the 8 inch floppy disk, that is), but weren't popular until the mid-70's (with the 5.25 inch disks). C is from 1973, so I think the answer largely depends on what you call "first version" and what the compiling context was. Think of these variables:

Used libraries. When compiling a library that's not on the current disk, you'll have to change floppy disks in between.

Complexity of the program ("Hello world" isn't the same as "the Norton Commander")

Hardware (personally, I think serious compiling was almost always done on mainframes or minicomputers)

After all - these days, compiling still takes several minutes - just adjust the tradeoff between your hardware and the complexity of the program. Only the floppy disk part isn't :-).

Take also into account that much computing in the 70's was still done on a terminal-mainframe construction, so changing floppy disks is maybe somewhat unlikely (at least in a business production context. I don't know whether C was used as a "home" language).

The "first" version did not run on floppies. It was a hard-disk based PDP-11 system at AT&T. However, the first version for a computer with floppies (i.e. CP/M, MS-DOS, etc.) was pretty difficult to manage.
–
S.LottFeb 24 '11 at 11:19

I remember seeing a floppy (removable disk) from the 60's. It was 4 feet across. They were mounted on plywood so they could be rolled around the lab. Held about 5K as I remember.
–
Loki AstariFeb 24 '11 at 16:30

You don't want to replace THAT one for each compiler run! Would love to see a picture of that one :-).
–
vstrienFeb 24 '11 at 17:46

My first foray into learning C was on a Commodore 64 (yes, there was a compiler for it), back in the late 80's. If I recall correctly, the compiler/editor/linker was on one disk and your source was on another and you had to swap at least once during the compile stage. Of course, on the C-64, you where always swapping.

For what it's worth, I still have the box and docs for that compiler. Makes for some nostalgic reading every couple years.

I also learned C on the Commodore 64 back in 1984. I remember swapping floppies during compiling quite clearly. I want to say that I was using a compiler by Abacus, but I might not be remembering that correctly.
–
Clint MillerFeb 24 '11 at 18:43

@Clint:I had the same compiler. The Commodore 64 was an awesome computer to learn programming on. It was advanced enough to do some really cool stuff but simple enough that you could understand all the hardware you needed to interact with, which was required because they didn't have the high level abstraction layers back then that they have today.
–
DunkMay 15 '12 at 19:00

My first C compiler was on a TRS-80 Model 4 running CP/M (the first model that would do so properly, not having low memory locations permanently mapped to ROM). It required the disk in the first drive to have CP/M on it.

Once I was through with whatever editor I was using, I had to compile, assemble, and link the program before I could run it. Each was its own process, kicked off at the command line. The compiler, assembler, and linker would not all fit on one floppy. (IIRC, the assembler and linker could fit together.)

Therefore, I'd have the program and editor on the CP/M system disk, and swap in the compiler and assembler/linker disks.

I was looking at a program that would allow me to run without having a system disk, and I had a plan (which I no longer remember) to set things up so I could make a little batch file and automate the command-line calls, but I never followed through.

I pretty much gave up on C after trying to use that system, and went back to Pascal for several years.

@quickly_now: Something that compiled to p-code, but it wasn't billed as UCSD. Naturally, I got rid of it decades ago, and remember little about it. When I got Turbo Pascal, I pretty much forgot all about it.
–
David ThornleyFeb 25 '11 at 14:50

When I was in High School (1989-1990) We were doing pascal on an apple II and It was SLOW. you could write a program of 100 lines or so when you hit compile it took a few minutes. I remember that you had time to go hit the mens room while it was compiling before the program would run.

About half way threw that term I got a Mac SE which was so much faster! Think Pascal was so much better.

The father of a friend of mine was a high profile programmer back in the day. He got tired to wait for the results of his compiles, days, sometimes week. Worked mostly from home, write the program, punch the cards, drive over, give the box to the operator and argue for a while his code was more important that all the others and wait.

Sometimes the code never reached the computer, my friend told me the story of the time his father really, I mean REALLY got mad at him. He never really understood why until much later in life but boy this box full of rigid papers looked like fun... hey their full of holes too !!!

One day he took the argument to management and I guess He made a good case cause they delivered a mini-computer to his house. I should mention that, by then, the computer took most of the living room which, of course, became off limits.

So yes, swapping disks between stages in a compilation is a definite possibility and trust me when I say it was a VAST improvement from what was available before that !!!

Just wait 20 years or so, I can imagine someone asking a question somewhat like :

Is it true that before, they had to use keyboards to type their code letter by letter ?

I don't know about C, but in that time frame for a while I had a microsoft Fortran compiler that took two passes. Not only that, but I had a page long program that it ran wrongly (I'm sure the sourcecode was right), so that was it, I gave up on compiling for the PC altogether. This was pre-internet days, and the PC belonged to my employer. It was still great to have the PC, I could put work on a floppy and take it home and edit it. So when I got to work the next day, I already had an edited program, rather then handwritten notes.

Even in the much earlier days, (I starting programming spring of 70), the compiler was a single JCL command on a batch processing mainframe OS. It just like described above. You waited in line for a keypunch, and punched your holerith cards. Then you handed them to an operator through a window. Depending upon the color of your PNC (basically a punched card containing account number/password), you might get your results back from 1 to 24 hours later. Low level students had the later turnaround. It really was a challenge to get the "hello world" assignment finished in the two weeks alotted for it! A couple years later I got a part time programming job, and could hang out at the computer center at night. Some of us could even feed the cardreader ourselves. Then turnaround ws only a few minutes/ But you could only do this late at night. All the serious CS types had completely skewed day/night cycles, as the only time you could be productive was late at night when demand was low.

So for a long time, compilers were mainly a thing for mainframes (million dollar class machines owned by very large organizations). And the few minicomputers around often had to be programmed in strange and tricky ways. I used one mini-computer to digitize seismograms. It took about 10-15minutes of guiding paper tape through it to boot the OS, then you would do your thing on the digitizer table.

Yes, for sure. I didn't use C on those old CP/M machines, I used CB-80. Compiled BASIC. (And yes it was pretty horrible). On a Heath/Zenith Z-89 with 2 floppy drives that each held 89K.

Single disk compilation was so horrible it was a case of forget it. Too much disk swapping. 2 Floppy drives was LUXURY! Source on one, compiler on the other. Set a compile going and walk away for a cup of tea while the machine went "clang clang clang" as the floppies were engaged and disengaged and the heads banged around.

The boss bought a 5 MB hard drive that was about 18x18x8 inches, separately powered, and attached into the back of the H89 with a ribbon cable about 4 feet long.

don't know about C (my first C compiler ran from a hard drive, and was not fast), but the first Macro Assembler I used (C64) required floppy-disk switching (one to load the assembler, the other to load the code), took 20+ minutes to build the system, and after a few months of development both the floppy disk drive and the motherboard overheated and died.

Before my time, I suppose. My first "real" programming (on PCs, anyway) was COBOL. At that time we used IBM PCs. They had 2 360k floppy drives; one had the compiler, and the other had your source code.

I do know that even my simple college projects took literally 15 minutes to compile running on those floppies - I'd run to the cafeteria for coffee while it was compiling. Then for the final project I worked on it at my buddies house. He'd just gotten a brand new machine with this thing called a hard drive - 10 megabytes! Our project compiled in under a minute. It completely blew my mind.

I had to do the floppy dance on my old 128K Mac for various applications, so I don't doubt this for a minute, although I couldn't give any details. I wouldn't be surprised if that's not part of why BASIC interpreters were so ubiquitous on early personal computers (no need for multiple passes, symbol tables, etc.).