Lambda the Ultimate

I don't know much about COBOL, but one of the biggest complaints is that it doesn't support structured programming because you have to use GO TO to create loops. This just isn't true and hasn't been since COBOL 74 or maybe COBOL 85. From what I can see, there is also better support for local variables from at least COBOL 85.

Most of the structured control-flow stuff was added in COBOL-85. No more need for GOTO or PERFORM THROUGH. You could write the Procedure Division for that example like this:

       PROCEDURE DIVISION.
       MAIN SECTION.
       MAIN-PARA.
           OPEN INPUT TAG2-FILE
           OPEN OUTPUT REP-FILE

      * Get the Date
           ACCEPT WS1-DATE FROM DATE
           MOVE WS1-YR TO WS1-YER
           MOVE WS1-MT TO WS1-MTH
           MOVE WS1-DY TO WS1-DAY

           SET NOT-TAG2-EOF TO TRUE

           PERFORM UNTIL TAG2-EOF
             READ TAG2-FILE AT END
                SET TAG2-EOF TO TRUE
             NOT AT END
                PERFORM A01-OP-LINE
             END-READ
           END-PERFORM

      * Print Control Report
           MOVE WS1-BLU-ADD TO WS1-BLU-TOTAL
           MOVE WS1-RED-ADD TO WS1-RED-TOTAL
           MOVE WS1-BLA-ADD TO WS1-BLA-TOTAL
           MOVE WS1-BLU-TOT TO WS1-BLU-COST
           MOVE WS1-RED-TOT TO WS1-RED-COST
           MOVE WS1-BLA-TOT TO WS1-BLA-COST
           WRITE REP-RCD FROM WS1-CONTROL-HDR AFTER ADVANCING 4 LINES
           WRITE REP-RCD FROM WS1-RESULT1 AFTER ADVANCING 1 LINE
           WRITE REP-RCD FROM WS1-RESULT2 AFTER ADVANCING 1 LINE
           WRITE REP-RCD FROM WS1-RESULT3 AFTER ADVANCING 1 LINE
           CLOSE TAG2-FILE REP-FILE
           STOP RUN.


       A01-OP-LINE.
      * Put Correct Colour Name in Sub Heading
          MOVE SPACES TO SUB-COLOUR
           EVALUATE TAG2-COLOUR
             WHEN "BLU"
                MOVE 'BLUE' TO SUB-COLOUR
             WHEN "RED"
                MOVE 'RED' TO SUB-COLOUR
             WHEN OTHER
                MOVE 'BLACK' TO SUB-COLOUR
           END-EVALUATE

      * If the number of lines printed > 57 then put up the page heading
           IF WS1-LCNT > 57
                ADD 1 TO WS1-PAGE-EDIT
                MOVE WS1-PAGE-EDIT TO WS1-PAGE-NBR
                WRITE REP-RCD FROM WS1-HDR-AREA AFTER ADVANCING PAGE
                MOVE ZERO TO WS1-LCNT
      * Output Colour Sub Heading
                MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD
            END-IF

           IF WS1-COLOR-CHECK NOT = TAG2-COLOUR
                MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD
            END-IF

           MOVE TAG2-ACC-NBR TO REP-ACC-NBR
           MOVE TAG2-TAG TO REP-TAG
           MOVE TAG2-PRN TO REP-PRN
           MOVE TAG2-QTY TO REP-QTY
           WRITE REP-RCD AFTER ADVANCING 1 LINE

      * Add up Tag Quantity for each Colour
           EVALUATE TAG2-COLOUR
             WHEN "BLU"
               ADD TAG2-QTY TO WS1-BLU-ADD
             WHEN "RED"
               ADD TAG2-QTY TO WS1-RED-ADD
             WHEN OTHER
               ADD TAG2-QTY TO WS1-BLA-ADD
            END-EVALUATE

      * Add up Tag Cost for each Colour
            EVALUATE TAG2-COLOUR ALSO TAG2-QTY
              WHEN "BLU" ALSO 24
                ADD 2.25 TO WS1-BLU-TOT
              WHEN "BLU" ALSO 36
                ADD 3.00 TO WS1-BLU-TOT
              WHEN "BLA" ALSO 24
                ADD 2.25 TO WS1-BLA-TOT
              WHEN "BLA" ALSO 36
                ADD 3.00 TO WS1-BLA-TOT
              WHEN "RED" ALSO 24
                ADD 2.25 TO WS1-RED-TOT
              WHEN "RED" ALSO 36
                ADD 3.00 TO WS1-RED-TOT
           END-EVALUATE

           ADD 1 TO WS1-LCNT.

with the addition in the WORKING-STORAGE SECTION of:

       01 TAG2-FLAG PIC S9(9) COMP.
             88 TAG2-EOF      VALUE 1.
             88 NOT-TAG2-EOF  VALUE 0.

With COBOL-2001 (and most compilers before that), you can say:

       01 TAG2-FLAG PIC S9(9) COMP.
             88 TAG2-EOF      VALUE 1 FALSE 0.

and SET TAG2-EOF TO FALSE

Of course, if I were really going to maintain this program, I'd translate the color name to an integer and use arrays and loops.

Nothing like the verbosity of COBOL, is there? :-)

As an aside--and this is an entirely syntactic issue, so I'm almost tempted to apologize for bringing it up?

but who finds the ALL CAPS SYNTAX OF COBOL and other languages of the era to be annoying? There is, of course, a reason for that--many terminals of that era didn't support lowercase letters--something that would chew up valuable bits on punchcards; I still remember my days on the Atari 8-bit machines, which didn't support lowercase letters in the color text modes (6 bits used to encode the character, in an ASCII-derivative called ATASCII; and 2 bits used to encode the color).

Of course, we still have SQL. :)

In my experience, COBOL compilers are case-insensitive, but coworkers are not.

So are SQL engines -- at least, all the ones I'm familiar with.

I know that people say that COBOL is verbose, but if it was meant to be easier to read than to write. Then it does what it was designed to do well.

I really quite like the look of the improved code above and think that I might look further into COBOL. I can certainly see how it must be easier to debug.

but if it was meant to be easier to read than to write

It's always seemed to me that languages like COBOL create easy readability of trees at the expense of making the forest incomprehensible.

Well, I like the EVALUATE statement in COBOL. This example shows some features not in many languages switch statements:

evaluate some-string also some-number
  when "FOO" also 1
  when "FOO" also 2
  when "BAR" also 1
    perform something-for-these-three-cases
  when "BAR" also ANY
    perform something-for-other-bars
  when "FOO" also 3
    continue
  when other
    perform default-processing
end-evaluate

Note how you can have multiple WHENs with a common statement. If you want to have a WHEN with no action, you can put in the no-op CONTINUE.
There's an ANY expression that will match anything. There's a default WHEN OTHER clause.

You can also use it like a LISP cond:

evaluate true
   when A < B
   when A > B
     perform paragraph-1
   when A = B AND A = C
     perform paragraph-2
   when A = B AND A > C
     perform paragraph-3
   when other
     perform paragraph-4
end-evaluate

This is equivalent to

   if A < B
   or A > B
     perform paragraph-1
   else if A = B AND A = C
     perform paragraph-2
   else if A = B AND A > C
     perform paragraph-3
   else
     perform paragraph-4
   end-if end-if end-if

but more aesthetically pleasing. There's no ELSEIF in COBOL so you either need and equal number of end-if's or a period--but the period also ends any enclosing statements.

Other than the EVALUATE, I can't think of much to like in COBOL.

might be worth considering sticking with the jvm, but going with a language which supports something like that e.g. Scala or whatever. it used to be that "java" == both the jvm and the language (unless you were some crazy bytecode hacker :-) but now there's i think enough choice on top of the jvm to be able to find a sweeter spot than the painfully unhelpful normal java syntax.

There are companies whose software handles record keeping for a significant portion of the US economy that process millions of transactions in nightly batch cycles (batch due to the time of market close and security pricing based on stock prices). I saw one application that ran on mainframes that generated 50 terabytes of data a day. Moores law hasn't negated the mainframe advantage yet in this regard.

There are a couple of Cobol to Java conversion products around. I've read that performance of generated code is not so good because Cobol numeric types require a BigDecimal type of array manipulation and Java bounds checking is a major performance penalty in that regard.

that the array indices are stored as BigDecimals, requiring a more expensive (than a simple ALU operation) boundscheck?

About the only language I can think of that permits fractional array indices is Cg, a graphics-oriented C derivative proposed by one of the GPU vendors (3Dfx?) a while back--if you passed a fractional index into an array, it would interpolate the data for you.

Moore's Law hasn't done all that much for I/O speeds; other than make it more of a bottleneck.

> if you passed a fractional index into an array, it would interpolate the data for you.

That is utterly brilliant. Stan Kelly-Bootle is finally vindicated! =)

Cg doesn't really have arrays. It has texture maps, which are sampled two-dimensional signals, and operators for evaluating the underlying signal at arbitrary floating-point positions, by reconstructing the continuous signal from its samples (by linear interpolation.) A large fraction of the hardware in the graphics cards that Cg runs on is devoted to exactly this operation, so it's unsurprising that the feature appears in the language. Since texture maps are the only data storage available on the hardware (other than a small register file) it's also unsurprising that programmers use textures to store arrays and just about anything else you can think of.

I agree about the web being an awful development environment. I have developed a reasonably large web app and I pull my hair out at the inefficient way of doing things to keep track of state. As far as I am concerned the only reason that web applications are still so popular is that so many of them rely on advertising and they also rely on being found by google.

the only reason that web applications are still so popular is that so many of them rely on advertising and they also rely on being found by google.

The only reason they are so popular is because they are a well-understood medium for delivering portable applications one can access from anywhere with a network connection, with virtually any device, even low-powered ones, and allows companies to keep their precious IP on their own servers where it can't be disassembled. I think you'd be hard-pressed to find a language or framework that can provide those same advantages.

Telnet was used previously and worked really well. What I think we really need now is a graphical version of telnet so that we can have proper stateful control over our applications in a pleasing windowing GUI.

For anyone who has written anything but the most basic of web apps vs proper distributed applications, they will know that really web apps are just bodges and hacks cobbled together. This is fundamentally true no matter how well designed they are.

Given my mainframe experience I was somewhat amused when CICS was mentioned, and it is true that many MF applications are written in COBOL, but even there the connection is weak. Applications can be written in many other languages as well (indeed, nothing beats BAL and IMS... CICS and COBOL is for wimps...) But really, this angle is not going to bring us any closer to PLT issues. As regards staeful programming models, I think the connection is going to be yet another discussion of continuation based systems, a subject discussed here many many times. The archives are your friend.

What I think we really need now is a graphical version of telnet so that we can have proper stateful control over our applications in a pleasing windowing GUI

I agree very much about this, and I am extremely surprised that no such interface did appear.

More specifically (at least from a Linux or SunOS perspective) I am still wishing a more friendly user interface than the command line. (On unix, the underlining tty interface is a huge mess; nobody cares about a VT220 interface anymore!). I would like some sophisticated terminal like interface.

For example, it would be wonderful if a markup language similar to HTML would exist, but without any navigation abilities. One could dream of a terminal handling a sequence of "pages" with input boxes, buttons, etc...

More related to programming languages, I also find pitiful that our programming languages are still textual (and that our code is edited under Emacs, which I do like). We still have no way to add (without an extra syntax) bold and italics in comments, greek letters in identifiers, hypertextual links in code.

Regards.

At the risk of flying off at a tangent

> I also find pitiful that our programming languages are still textual

Some are not, but there is a long way to go.

So far we have (off the top of my head):

• SynthEdit is a way of programming synths and audio effects visually; why is that considered an "application" and not a "domain-specific visual programming language"?
• Conal Elliott's Tangible Values is a bold step towards real visual programming; I wait for "real" applications of this with baited breath, but feel that the mental gap most of us programmers will have to leap is perhaps too wide.
• Python has doctest, the ability to plonk test code into comments. That's still textual, but (when married with a folding editor) gets away from one serious annoyance with linear, textual languages which is that multiple views of the code cannot coexist without clutter. In this case a (kind of) use-case view together with an implementation view.
• UI builders have been with us for some time, but the integration with "real" code is weak. When will the visual aspects be given equal footing?
• Useless UML round-trippery.

And we have not (as far as I know -- please correct me if I've missed something exciting):

• Visual state machine programming where the diagram is first-class.
• Visual dataflow programming (Haskell's Arrows are programmed in a cute flattened-diagram way; don't you wish you could represent the dataflow in two dimensions?). Domain-specific applications of this such as SynthEdit exist, but not AFAIK general-purpose.
• GUI Mock-ups existing as first-class objects that "run" whenever that portion of "real code" is missing, and validate the code against use-cases where code is present.

Given the amount of effort so far poured into UML, this seems a bit pathetic, no?

"What I think we really need now is a graphical version of telnet so that we can have proper stateful control over our applications in a pleasing windowing GUI"

I agree very much about this, and I am extremely surprised that no such interface did appear.

XWindows...?

For example, it would be wonderful if a markup language similar to HTML would exist, but without any navigation abilities. One could dream of a terminal handling a sequence of "pages" with input boxes, buttons, etc...

This sounds a bit like WAP.

For anyone who has written anything but the most basic of web apps vs proper distributed applications, they will know that really web apps are just bodges and hacks cobbled together. This is fundamentally true no matter how well designed they are.

I disagree. Also, stateful systems don't scale as well as stateless systems, as they are more vulnerable to DoS.