Just pound

From Darren, who is amused by FTP being thought of as the old-fashioned way (and we can notice that FTP would rely on the Internet service working anyway).

Darren adds: “Cobb [this dog] is always the ‘straight man’ for setups and is sane and predictable.  But in this final panel he’s pounding on the keyboard.  Also, assuming Tucker [the boy] is mentioning this because it is nearly the deadline for the homework, what is the old fashioned way that Cobb is thinking of?  Presumably turning it in before leaving the class is not an option.”


  1. He’s not in class, he’s working from home. The rank of the effective “solutions” would be
    1) “FTP” = old(†), and ineffective (no Internet = no file transfer);
    2) “banging the keyboard” = older, more satisfying, but still ineffective (like “kicking the tires”);
    3) “printing it out and getting it postmarked before 6pm“: ancient, unorthodox, but perfectly acceptable.

    P.S. (†) – FTP may be seen as antiquated, but it is still very much in use. Ordinarily I would cringe to think about the massive amount of Fortran and Cobol code that is still running in all sorts of systems(‡), but considering the reliability of more modern systems, there is something to be said for an application that has been running correctly for over 40 years:

    P.P.S. (‡) – Including encapsulated routines written in PL/I.

  2. Wouldn’t the old fashioned way be to print it and submit it in person? If it’s close enough to 6pm to worry about the internet being up, probably nobody would be at school to accept it. Maybe faxing it?

  3. Kilby, I too am amazed at how much Cobol and Fortran code is still out there, but on the other hand, what’s running is not Cobol or Fortran but their compiled machine code. If it does the job, and the job hasn’t changed in 50 years, then why not?

  4. @ Boise Ed – That is a major reason to congratulate the developers of the (newer) compilers. The ancient machine code would probably not run perfectly on modern CPUs(†), but that dependable source code still produces dependable machine code.

    P.S. (&dagger) – Yes, I do know that it was possible to run Commodore 64 games running on a c64 simulator within a DOS box under OS/2, but such shennanigans are just intellectual diversions for nerds.

  5. COBOL was designed to be machine independent. Fortran was not.

    When I worked at a computer service bureau, back in the days when most companies didn’t have their own computer, we had an IBM 370 and we got a customer who had been running their Fortran code at a different service bureau with a different make of computer. I don’t remember what it was, but it had 36-bit words. The 370 has 32-bit words. The software was accounting programs using Fortran floating point. The loss in precision was just enough to make the totals inaccurate, like 350,000.12 + 350,000.12 = 700,000.25. We tried to fix it by making all the variables double-precision but then the program wouldn’t fit in memory.

    For some reason, a lot of my early career involved dealing with software written in the “wrong” language. Accounting software written in Fortran. String-processing software written in COBOL. Device control programs written in BASIC. Business transaction processing in IBM 370 Assembler.

  6. MiB: I remember once when I was assigned to document some Fortran spaghetti code. What a mess!

  7. @ MiB – If I recall correctly, that jumped to the respective labels when (X) was negative, zero, or positive. There was a similar spaghetti-making contruct in BASIC: “ON (X) GOTO 1,2,3,4,…“, for a positive integer X, but the deadliest implementation I ever encountered was in the early 1980s (possibly Sinclair BASIC), which allowed (and executed) statements in the form of “GOTO (X)“, jumping to whatever line number that happened to match the value in the variable X.

  8. Fortran was very machine-oriented. I read once that the reason Fortran arrays allowed up to 7 dimensions was that the IBM 701 had 7 registers that could be used as index registers. I don’t know the 701 instruction set, but the IBM 360 had condition bits. After an arithmetic operation, the condition would reflect the result as zero, less than zero, greater than zero, or overflow. So for “IF (X) 34, 35, 35” the program would add zero to x to set the condition bit, then branch if less to 34 and branch if equal or greater to 35. If you knew the machine’s instruction set, the language constructs made a lot of sense.

    I think Fortran had the “ON (X) GOTO” construct, which would set up a jump table indexed by X. I don’t remember if it tested X to see if it was out of range.

    Did you ever try this in Fortran? Write a subroutine like this:

    X = 7

    and then call it like this:



    From that point on, the value of the constant 4 is 7. As they say, “Constants aren’t; variables won’t.”

  9. I remember trying out the FORTRAN constant thing. It only worked if you linked an OMAGIC binary with writeable text; otherwise the constants ended up in text (or maybe readonly data) and the assignment dumped core. This would have been with DEC’s FORTRAN on Ultrix in something like 1991 or 1992. I imagine nowadays if you try to create a program with writeable text the linker (or the OS) will just laugh at you. 😐

  10. The last time I used Fortran was about 1978. The language was very trusting back then.

  11. You can definitely do the change-the-value-of-a-constant thing in ALGOL-60 with call-by-name subroutine parameters.

  12. I was in the first class that learned to program a computer in high school. The business classes had been learning data processing before – but no programing had been taught. We learned Fortran and used cards to input the program into the computer. Cards went into a computer sized device which served as the compiler. The cards it produced were then fed into the actual computer. Generally one would then have to start over with the original cards to find their error(s), then repeat. One big advantage was that computer classroom was the only room that was air conditioned in the school.

    In college learned to program the mainframe computer using Basic. It was no longer in the classroom – it was “somewhere” and could be accessed from various places around the campus. Husband copied my homework in that class. (He was not my husband then.) Over the decades he became the family computer expert and deals with the computers for me.

    When we took apart my family’s home one of the items I did not know I still had was the manual for my high school computer course – it was one of less 30 things that I took from the house. (So now it’s here – somewhere.)

Add a Comment

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.