

220 Billion Lines of COBOL? BS - baha_man
http://www.knowing.net/index.php/2009/08/10/220-billion-lines-of-cobol-bs/

======
root
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.

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

------
thaumaturgy
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.

~~~
billswift
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.

~~~
thaumaturgy
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.

------
mgrouchy
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.

~~~
Retric
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.

------
ryansloan
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.

~~~
AndrewDucker
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.

------
dkersten
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.

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

~~~
dkersten
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).

------
dimitar
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.

------
ShabbyDoo
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.

