We started with mathematical expressions, abstract algorithms, and the idea of code — a list of instruction steps in some code language. We touched on how all algorithms have an abstract state diagram (a flowchart) representing them. Then we looked briefly at the stored-program physical machines that execute code.
Before we go on to characterize the complexity of a computer, I want to take a look — very broadly — at how the computer operates overall. Specifically, look at another Yin-Yang pair: the computer’s operating system versus its applications.
This has a passing relevance to the computer’s complexity.
Hardware, generally speaking, is anything you can actually hold in your hand. (Or on a forklift, if necessary.) Software, generally speaking, is data, pure information.
But wait! Suppose you burn your software on a CD that you can hold in your hand. Isn’t that hardware now?
In a sense yes, which is why the distinction isn’t as simple as physical object versus abstract information.
And yet it is exactly that simple.
The CD is a piece of hardware, true enough, but the pattern of bits burned into it only represents the software. The actual software is an abstract state diagram — a process.
What’s more, even if every physical copy of the software was destroyed, if it had no physical representation at all, not even a PowerPoint flowchart, the abstract state diagram, the algorithm, still exists.
So hardware is the metal and plastic and wood (and ceramic and cloth and whatever). Software is abstract information. (Obviously, software has to be reified, made concrete, in some fashion for us to use it.)
Another way to look at this is that a hardware thing cannot be perfectly duplicated — no real world object can. But a copy of software is a perfect copy, truly identical in every way that matters.
We looked at the basic architecture of modern computer hardware. Now we’ll look at the basic architecture of their software.
It starts with a fundamental division between system code (often called the operating system) and user code (often called applications). For many users, the hardware and the operating system comprise “the computer” to which they add their desired apps.
As we explore these, we can make an analogy with people. The computer hardware, obviously, compares to the human body, but, as it turns out, the software is a little harder to fit to the model.
A computer’s operating system (O/S) is a suite of software that controls the computer itself. In particular, the O/S is usually responsible for managing the file system, I/O (keyboards, monitors, etc), and the execution of all software (including itself).
There are usually four major parts to any O/S.
The code here usually does just two things: It provides, as the name says, basic I/O functions appropriate to that physical system. It provides just enough code to boot the computer when it starts up.
CPU chips are designed to start executing code from a predefined place when they first start (when power is first applied or when a hard reset occurs).
The BIOS chip is set up so the system boot code is what the CPU does first thing.
That boot code usually is just enough to check the physical system for gross problems. After that, it looks for the O/S loader, which might be in several places. The boot sector of the main hard drive is usually the first place it looks, but systems can be set to (for example) load from a CD-ROM drive — even an inserted memory stick — first.
The O/S loader code is the second major part. As with the system boot code, this is a small chunk of code (it has to fit in a disk boot sector) just smart enough to begin loading the operating system itself.
The O/S, the third (and by far largest) major part takes its sweet time booting, checking out the system, retrieving registry keys, configuring I/O ports, establishing internet connectivity, and doing lots of other mysterious operating system-y things while we stare at the screen.
One of the key things it does is install and start various services (aka drivers aka daemons), which are the fourth major part of the O/S.
Services are part of the O/S in controlling the machine and providing function, but distinct in often being from other parties. For example, a printer manufacturer will provide services that allow full use of all their printer features.
One of the biggest things an O/S provides is the virtual machine that user code — applications — run on. Computer hardware has a lot of variation, and the O/S provides a layer of abstraction that insulates application developers from having to write code that knows about all that variation.
Application developers write for the operating system, and the operating system worries about the details of the local machine. And even the O/S leaves some details to the BIOS code that came with the motherboard!
Computer applications are pretty much anything the user dreams up, from games to work tools. There are apps for science and mathematics as well as apps for music (writing and playing) and all forms of art (creating and enjoying).
Comparing this set up to humans is tricky. We’re born with some instincts and tendencies. (We’re social animals and thinkers; we like music and laughter.)
On the other hand, we’re born fairly tabula rasa. We can’t walk, swim, talk, or run, for years. Becoming a useful member of society typically takes decades (well, two at least) and a large investment in training. (It is said that it takes 10,000 hours to become truly proficient in anything.)
A great deal of what makes a person who they are is learned. At the same time, any parent will tell you children have distinct personalities from very early, and most people’s core personality doesn’t change much over their lifetime (absent major psychological or neurological trauma).
The nature or nurture debate is an old one, and a difficult one to solve (the two are deeply interconnected in normal people). I don’t particularly want to get into it here.
One thing we can say is that, just as the hardware of a computer constrains what it can do and how it does it, so too does our physical brain constrain how and what our minds can do.
I don’t know to what extent you can really compare a new-born infant to a computer with no software loaded (just the BIOS), but it seems not too far off the mark.
Infants have some very basic “I/O” ability, but they certainly aren’t ready to run any “applications” (it was a few years before even Mozart kicked it into gear).
We spend years “installing” their “operating system” so that they can begin the even longer period of learning useful applications. In theory, our early years in school teach us basics and, importantly, how to learn new things. At some point we begin learning things — skills — that interest us.
So perhaps the analogy is from infant to raw system with just BIOS. Not very useful, but filled with potential. Childhood is the process of installing the O/S, and once that begins to take, the process of installing applications begins.
Instincts and (inborn) talents perhaps have some correlation with the hardware architecture of a system. Certain physical designs lend themselves more to some tasks than others. Someone with a “powerful” mind might be likened to a 64-bit processor or one with a high clock speed.
In closing, I can’t resist a comment about how operating systems have become defining features in the PC world. The Apple-Windows divide, for example, is pretty much a religious one. Certainly an image thing — remember those commercials with the PC guy and the Apple guy?
One of the funniest bits I’ve ever read (to this day) about the operating system wars is by Neal Stephenson. It’s chapter two of his neat little non-fiction book, In the Beginning Was the Command Line. I highly recommend reading it to anyone in the computer field.
Next time we’ll begin characterizing the complexity of a computer and, after that, the complexity of the human brain! Our ultimate goal is trying to figure out the requirements involved in creating a working software model of the human mind.
 Physicists believe information cannot be destroyed (which makes black holes a problem, but that’s a whole other topic).
 Assuming we don’t screw up the copy and introduce errors. A canonical example involves a photograph and a paper filled with numbers, both of which are faded, yellowed, creased, coffee-ring stained, and otherwise mildly damaged and aged.
Modern analog image processing techniques can do a lot with the photo to create a very good copy, but it will never be perfect. But the sheet of numbers can be copied to a pristine sheet and the result is, in every way, as perfect as the original was.
 The problem question is: If we compare the physical brain to a CPU — an engine for running software — then where is the software it runs? The answer seems to be: Wired directly into the construction of the brain.
This leads to a more serious question: To what extent does this construction work like a Turing Machine (whose program, incidentally, is also wired directly into its construction)? Any hope of understanding the putative software of the human mind depends on understanding this.
 A peculiarity is why we put a slash in “O/S” and “I/O” but not most other acronyms. Is it just because “OS” and “IO” look too much like real words, or is it just to make them more computer-y?
 Which leads to one of my favorite error messages of all time: Keyboard not attached! Press F12 to continue.
 Those of us in the Unix world saw both of those somewhat as pretenders and didn’t care.
 It is freely, and I believe legally, available online. It’s worth grabbing just for the second chapter (MGBs, Tanks, and Batmobiles).