220 billion doesn't sound all that big to me. Let's say there are 100,000 firms that use Cobol, that would mean 2.2 million lines of code per firm. Since even a fairly trivial report coded in Cobol is easily 1000 lines (source: ran wc on my old Cobol directory), this would be the equivalent of about 2200 simple reports per firm. This is a very low number considering there is bound to be more complex transaction processing code, lots of (even more verbose) code generated by code generators, and the tendency to have lots of tweaked versions of the same program.

Agreed. My own corp still runs 8000 of these reports weekly, plus extracts, etc....

I posted the following comment to this article (currently awaiting moderation):

You stepped right onto one of my pet-peeves, so as calmly as I can, I'd like to explain why the whole Y2K bug turned out to be a non-event: because a lot of people -- myself included -- spent months poring over countless lines of, yes, COBOL (among others), and writing in year-windowing functions and the like.

In 1999, I was working for a large, affluent public school district in the East Bay in California. We had a Unisys mainframe -- and to the best of my knowledge, they're still running most of their stuff on it -- that was responsible for their accounting, their finance, their payroll, and all of their school operations.

If it only weighed in at a million lines of COBOL, I would be surprised.

And layered on top of that were, probably, tens of thousands of lines of WFL.

We spent months auditing (and patching) all of the functions in that systems.

When all was said and done, only a few unanticipated systems broke in the months following January 1, 2000.

However, had we not done all that work, I can assure you that nobody would have received a paycheck in January.

The people that always point to the end results of the Y2K bug as an example of unfounded hype bug me to no end. Have you even ever talked to someone that did Y2K work? I did, and it was not a picnic, and yes, a lot of things would have been broken if we hadn't done it. (Hell, there was even a critical patch for Sun DNS servers that had to be applied; I know this, because I applied it, and fought it with as it didn't work out quite right.)

As for 200 billion SLOC for COBOL ... yes, that seems a bit high, but I don't honestly think it's off by an order of magnitude. We were a little tiny system by lots of standards, and we were running easily a million lines of COBOL, and a huge chunk of it was custom code and in-house patches.

I think you're a bit backward on Y2K; instead of being down on those who correctly said that the hypsters were full of it, you should be irritated at the hypsters who were effectively claiming that you and the other programmers who patched the problems before they became problems were too incompetent to do your jobs.

That's not the sense I get in most discussions like this, although I hadn't thought of it that way before so it's possible that I'm letting my own biases come into play here.

The sense I get is that the Y2K bug was a non-issue to begin with -- the usual evidence for this being that there were very few problems following January 1 -- which I think really marginalizes the huge amount of extra effort that a lot of people put into making sure that it would be a non-issue.

_If_ legions of programmers hadn't done their jobs, and done them very well, then the hypsters probably wouldn't have been very far off the mark.

Honestly, Im pretty sure that for example all the Canadian Government payment stuff(so handing EI, pensions, and every other program that makes a payment to the public or other government entity) is written in COBOL and on top of that there are endless reporting tools and such written COBOL to report on such payments. I can't imagine that the canadian government is the only one to have done this.

I mean 220 Billion is a lot, but I can't imagine that the real number is that far off.

As a sanity check, there are 400,000 Cobol Programmers that have written on average 1,100,000 lines of code 50% of which is still in use today.

I think all of those numbers are extremely bloated. 100,000 * 250,000 * 10% might be possible.

I think 220 Billion is a highly inaccurate number as well, but I'm not sure if I agree with his assessment of the Y2K stuff.

Granted, it -was- overhyped (stock up on batteries, rice, haz mat suits, etc.) but there would have been fairly significant problems if the companies developing these systems didn't prepare. The possible effects were exaggerated, but I still think it's a better example of "crisis" management than mass delusion or panic.

Agreed. Lots of code would have failed without significant amounts of work. That almost nothing broke on the day is down to a lot of very hard work.

I can believe there is that many lines of COBOL, after having learned and having to maintain/write COBOL, it's verbosity causes small simple programs to span hundreds of lines.

I dunno, personal friends of mine have worked on COBOL code and I'm definitely NOT old enough to have been around during COBOL golden age.

Also, regarding Y2K, I imagine if power plants and such were not updated, we'd have been in a bit of trouble.

You don't write software for power plants in COBOL. COBOL is intedned for stuff like managing payrolls, not control engineering.

Ok then, financial institutions. I know a lot of the Irish Revenue legacy systems are in COBOL. Y2K could potentially have affected that too (though obviously nowhere near as drastically as a power plant).

Gartner who made this claim in 1997 most probably knew what they were talking about. It is pointless to argue about old data, as if it were new.

I suspect 220B is quite an exaggeration, but there may be a difference between the number of unique lines of COBOL and the total number of uniquely deployed source instances. I wonder how many 80's era third party apps there are that are installed on 1000 different mainframes around the world. A couple hundred thousand lines x 1000 machines puts a dent in the 220B number.