I am a dinosaur. Most of the people reading this are Borg. You are the future. My kind is all but extinct.
I, Dinosaur
Back in the days when we dinosaurs ruled the earth, computers were simple. They couldn’t do much, but that didn’t bother us: if you needed something the computer couldn’t do, you just slapped together your own circuit board with some chips, soldered it all together, and poof! You had what you needed.
Programming was simple, too. First you wrote your program down on paper, then you typed into the computer. If you were really cool, you even had special paper for your code:
But the most important thing about this was that you had complete, total, absolute control over the computer. There was almost nothing in the computer that you didn’t directly control. Yes, there was an operating system on most of these computers, but even that was quite simple. Here’s how you read a file in Jurassic times:
THEFILE = OPEN(2, 92, “FILENAME”);
READ(THEFILE, $3A00);
CLOSE(THEFILE);
The “2” specified which drive number you were addressing; the “92” specified whether you were just reading, reading and writing, or just writing. And the “$3A00” specified the address into which you wanted the data read. Quick, simple, easy to understand.
There was no Internet available to us at that time. We worked in isolation. The only sources of information for us were books such as Adam Osborne’s “An Introduction to Microcomputers” and magazines like Creative Computing, Byte, and Kilobaud. By the way, the name “Kilobaud” was meant to indicate high technology. Back then, we used acoustic modems operating at 300 baud, so a kilobaud was over three times faster than the standard!
Another bit of terminology: the terms “boot up” and “boot disk” arose from the fact that the early minicomputers came with only the barest minimum of hard-wired operating system. When you turned on a PDP minicomputer, it was capable of just one thing: reading a paper tape. You had these paper tapes with punched holes that were folded into stacks. You placed the paper tape into an input hopper, and fed the beginning of the tape into the little reader. It would take over and read the data into the memory. That data comprised the full operating system. Once it was all in place, you could start to use the machine. In effect, you used the tiny bit of built-in software to bootstrap your way up to the full operating system. That was shortened to “booting” and later “boot”.
Anyway, the key point here is that we were rugged individualists who figured out everything for ourselves. We made things up as we went along, and the machines and software were simple enough for an isolated individual to figure out on their own. That’s how we worked.
The Borg
The Internet changed everything. It enabled the rise of special interest communities. There are a zillion special interest communities. Whatever your interest, from armadillos to zebras, there’s a group of like-minded people on the Internet. And there are zillions and zillions of special places just for programmers. It’s not just the hottest, newest programming languages; there are support pages for such ancient languages as FORTRAN, COBOL, and ADA. Unfortunately, these web pages are written in Latin, so you’ll need some preparation before using them. Also, the s’s look like f’s.
At first glance, this seems wonderful. No matter what your problem is, you can always go to a support site and get help. But it has also had the pernicious result of permitting the most godawful software designs. Software doesn’t need to be intuitive anymore, or even make sense. If you don’t understand something, just plug yourself into the hive mind.
The Borg have completely assimilated software—all software. It is now out of the reach of mere humans; the only way to learn software is to become part of the hive mind. Software developers don’t even try to write proper documentation for their products. Instead, they provide a skimpy outline adequate only for learning the basics. After that, you must turn to the hive mind, become part of it in order to learn the finer points of any piece of software.
The proof of this dismal realization arises from Crawford’s First Law of Software Design, which requires you to ask over and over, about any piece of software: “What does the user DO? What are the verbs?” If you know all the verbs, you know everything there is to know about the software. If you’re designing a piece of software, the verb list is your fundamental design document.
With that in mind, I offer the following simple challenge: for ANY piece of software, can you prepare a complete verb list? I’m sure that there are some simple games for which this might be true. But for any real piece of software, are you sure that you’ve gotten every last verb? For example, Firefox, a mere browser, includes 50 separate menu items, some of which are merely the entry points for nested menus. Other menu items raise dialog boxes that present the user with even more verbs. Then there are all the little teeny icons running across the toolbar at the top of the window. Many of these merely replicate menu items, but they still count as verbs. At least, you still have to figure out what they mean. My guess is that Firefox incorporates only about a hundred verbs, but I don’t think that anybody can come up with a dead-certain verb count. It’s just too complicated.
I must admit that it is obvious that the Borg Collective has contributed to the overall progress of software. No longer need any one person master the entire range of technologies that they use. The Borg Collective allows greater specialization, with each person mastering some tiny corner in the vast Borg Cube of software, and sharing that knowledge through the hive mind of the Internet as needed. At the same time, the individual Borg has the massive database of knowledge of the hive mind readily available. It’s faster, it’s more efficient, and it permits us to build ever more complex software.
However, it’s not without its problems. Recall the example I presented above in which I read a file in the old days. Well, here’s how it’s done nowadays in JavaScript:
const ajax = request => {
let r = new XMLHttpRequest()
r.open(request.method, request.url, true)
r.setRequestHeader('Content-Type', 'application/json’)
r.onreadystatechange = evnet => {
if (r.readyState == 4) {
var json = JSON.parse(r.response)
request.callback(r.response)
}
}
r.send()
}
let request = {
method: 'GET’,
url: 'your.server.url’,
callback (r) {
// here goes the code handling Json data
}
}
ajax(request)
This is progress?
As one of the last remaining dinosaurs, I must accept my obsolescence and salute the triumph of the Borg. Resistance was futile.