Note: "victim" is not victim's real name or real IRC handle. Every word that follows is true. This conversation really happened.
<cowan> | I mean, <3rdParty>'s a Cobol programmer by training. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Right. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Which I've met essentially none of. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Cobol programmers don't use subroutines. They're too inefficient. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Dude, you need to put up warning tags. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | That literally hurt. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Ow ow ow ow ow ow ow ow ow. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Cobol uses things like PERFORM A THROUGH B, which means "execute the statement labeled A ,then consecutive statements until after the statement labeled B has been executed, then return. That's efficient. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | That just takes "old school" to a new level. One that ignores the last 30 years of computer science. . | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | If there happen to be lots of GO TOs before B is reached, fine! | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Cobol even has the insane ALTER A TO PROCEED TO B statement (though <3rdParty> says it, at least, is obsolete): | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | That means: Look past the statement labeled A until you find the next GO TO statement (of course, the looking is done at compile time) ... | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | STOP IT YOURE HURTING MEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE! | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | ... and patch it into being a GOTO B statement. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHHHH! | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
* victim | pouts. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Naturally, when code gets paged out, the ALTERs in the paged-out code are forgotten. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | OMFG, you just don't stop, do you? | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Wait a minute, wait wait wait. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | The looking is done at compile time, but the altering is done at run time? | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Yes. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | After all, you might execute ALTER A TO PROCEED TO C next. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Congratulations, you just made me scream out loud. Literally. I'm not kidding. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | I'm contemplating suicide for belonging to a species that could do this. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | (OK, that second part is not true, but the first is) | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Dude, you're the Sail, I'm the Anchor. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | In a heavy wind, the Sail can tear itself loose if it ain't strapped down tight. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Don't worry. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Yeah, but you're anchoring me to the fucking Scylla. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | OTOH, Cobol has some really cool features. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Given two variables of the same structure type, you can say "MOVE A TO B" to do b = a (structure copy). | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | But if you say MOVE CORRESPONDING A TO B, then A and B do not have to have the same type, | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | and only the elements of A that also exist (by name) in B are copied. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | That's vaguely interesting, yeah. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | It's also three lines of code in most languages. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Well, no. Suppose that A's type has fields b, c, d, e, f, g and B's type has fields a, c, e, g, h. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | Then it's equivalent to B.c = A.c; B.e = A.e, B.g = A.g | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | but if you add members to A's type or B's type, the compiler generates more assignments. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | No searching through the code to make it so. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | Right. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | C can't do that, but any language where you can inspect structure membership by name can. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | You can do this in Python or Lisp if you go meta, yes, but Cobol compilers do it automatically. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<cowan> | at full machine efficiency. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<victim> | foreach <cowan> | great minds think alike.
| <victim> | Ah.
| <cowan> | Back to the evils of Cobol: looping is done by things like PERFORM A THROUGH B N TIMES.
| <cowan> | So the loop statement doesn't need to be anywhere near the loop body, and often isn't.
| <victim> | These are all labels, right?
| <victim> | Oh fuck me.
| <cowan> | Yes, except when I was talking about MOVE CORRESPONDING.
| <cowan> | Now you can say COMPUTE A = B * C + D.
| <cowan> | But the real Cobol way is
| <cowan> | MULTIPLY B BY C GIVING X1
| <cowan> | ADD X1 TO D GIVING A.
| <cowan> | O' course, you better declare X1.
| <cowan> | You can add an ON SIZE ERROR to any of these arithmetic statements to say what to do
| <cowan> | if there is no room in X1 for the result, since it must be declared with a given
| <cowan> | number of digits, thus:
| <cowan> | WORKING-STORAGE SECTION.
| <victim> | NUMBER OF DIGITS?
| <cowan> | 77 X1 PICTURE 999999.
| <cowan> | Sure. All Cobol arithmetic is done in decimal digits.
| <victim> | Oh god, that's where pictures came from.
| <victim> | I've hit those before.
| <cowan> | Unless you add USAGE COMPUTATIONAL to the end of the picture
| <cowan> | in which case it can be binary or floating point.
| <cowan> | Note the magic 77, which means that this is not a structural variable.
| <cowan> | Structures are declared by starting with 01; fields and substructures are 02;
| * victim | whimpers
| <cowan> | fields in the substructures are 03; and so on. You don't have to increment the numbers
| <cowan> | by one as long as you increment them.
| <cowan> | Unless, of course, the structure will be used to hold a record from some file,
| <cowan> | in which case you use FD instead of 01, of cours.
| <victim> | You're enjoying the hell out of this, I hope.
| <cowan> | You can add REDEFINES to a declaration to show that it shares storage with some other
| <cowan> | declared element.
| <cowan> | (Are you kidding? My ribs are aching!)
| <victim> | Are you copying this from somewhere, or doing it on the fly?
| <victim> | Wait, wait.
| <victim> | Shares storage?
| <cowan> | On the fly.
| <cowan> | Sure. Suppose your data
| <cowan> | has either a SSN number or a taxpayer ID number but not both.
| <victim> | You're telling me that a language that has decimal digits as a storage unit also has type-casting?
| <cowan> | Yup.
| <cowan> | SSN PICTURE 99-999-9999
| <cowan> | TIN 99-99999999 REDEFINES SSN
| <victim> | Oh no, you're going to pattern match to find out which it is aren't you?
| <victim> | It's like C enums, but in hell.
| <cowan> | No. You can define the SSN field and read the TIN field.
| <cowan> | It's like C unions.
| <cowan> | Horribly abused.
| <victim> | Oh no, it really IS type-casting!
| <cowan> | Sure.
| <cowan> | All variables are global.
| <victim> | Please, for the love of goth, tell me this language doesn't have pointers.
| <victim> | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH!
| <victim> | You just threw that in there.
| <cowan> | More accurately, they're all static.
| <cowan> | But since most programmers don't use subroutines (which are called PROGRAMs)
| <victim> | I almost remember the difference.
| <cowan> | it's a distinction without a difference.
| <cowan> | static = stored in fixed location, but only accessible from the current PROGRAM.
| <victim> | Ah.
| <cowan> | Recursion is technically allowed, but without a variable stack it's sorta pointless.
| <cowan> | No pointers, no.
| <cowan> | Or at least only in Object-Oriented Cobol.
| <cowan> | Which is very recent and most Suzie Cobols (Sammy Cobols if they're female) don't know it.
| <victim> | There is OBJECT-ORIENTED COBOL?
| <cowan> | Yeah. I'm not up on the details.
| <victim> | So wait, you can try to do recursion, but variables are preserved throughout?
| <cowan> | yes.
| <victim> | Wooow.
| <cowan> | Then there's the CONTINUE statement. It does nothing.
| <victim> | Oh dear god. Why?
| <cowan> | But when you want to say THEN no-op, you say THEN NEXT SENTENCE.
| <victim> | Why?
| <cowan> | Screen I/O, sorting, and such are built-in language statements.
| <cowan> | You open a file with OPEN, but you don't mention the name of the file in the OPEN statement.
| <cowan> | Instead, you mention the name of the structured variable you want to read into.
| <cowan> | The actual association between the variable and the file goes in something called the
| <cowan> | ENVIRONMENT DIVISION up at the front. The file name has to be fixed.
| <cowan> | Ah, I just found out that the new, improved PERFORM A THROUGH B can now be PERFORM IN THREAD instead. Threaded Cobol.
| |