|P is for Practical|
Caution: The following article is very grumpy.
The article is about some super-genius named Jaron Lanier, who must be really k00l, because he hangs with Sean Lennon. Jaron has this to say for himself:
"The hardware side of computers keeps on getting better and cheaper at an exponential rate," writes Lanier. "[But] this breathtaking vista must be contrasted with the Great Shame of computer science, which is that we don't seem to be able to write software much better as computers get much faster."
Which is, uh, false.
OK, story time. Back in the 1970s, IBM assembled a big team of programmers to produce a new product. They spent millions of dollars and hundreds of programmer years. The outcome was the IBM Fortran H compiler. It was a really excellent compiler.
Back in the 1970's, that's how you wrote a compiler. That's how much it cost and that's how long it took.
These days, if you are nineteen years old and going to university to get a CS degree, you take a one-semester class called 'Compiler Design'. As your final project for that class, and maybe your midterm project also, you write a compiler. Total cost, zero. Total programmer-years, 0.67. It won't be a very good compiler, but a third-year CS student is not a very good programmer.
Jaron Lanier has the gall to say that we don't know how to write software any better than we did before, when every nineteen-year-old kid is now expected to do the work of a crack team of programmers in half the time.
Thirty years ago, Perl would have been completely unthinkable. There were 'list-processing languages' and 'string-processing languages'. Nowadays, if your language doesn't have list processing and string processing and a ton of other stuff, nobody will use it. People won't even bother to laugh at it. Thirty years ago recursion was a weird and difficult concept and most languages didn't support it.
Thirty years ago, there were no window systems. If anyone had had the idea to write a widget toolkit, they would have failed, because there was no OOP. Heck, forget OOP. Thirty years ago, there was hardly any structured programming.
Thirty years ago, regexes had just been invented and it was big news that you could use them for pattern matching. Thirty years ago hashes were a difficult concept.
Thirty years ago, nobody knew how to index 1300 million web pages and then instantly find the ones that people wanted. Nobody would have dared to try.
Thirty years ago, the idea of NP-completeness had not been invented. Nobody had the slightest idea that some problems were intrinsically hard. Nobody had even seriously thought that it might be possible for a problem to be intrinsically hard.
You may not believe how primitive was our understanding of network programming thirty years ago. Thirty years ago, the guys designing the telnet protocol for the ARPAnet (this was before the internet) were trying to figure out how the protocol should communicate the details of the line-wrapping discipline. Today if you tried to include line-wrapping in a remote login protocol, everyone would laugh at you. "Let the program on the remote end deal with it," they would say. They might add "Duh! Everyone knows that." They would be right. The ARPAnet guys eventually figured that out. Too bad Jaron Lanier wasn't around then; he could have saved them a lot of time.
Bah. Anyone who tells you that we haven't made progress in software is selling something that isn't worth buying.
"Great Shame of Computer Science," my butt.