This will explain the technology underlying the invention, beginning as simply as possible, and gradually proceeding towards the more complex.
Start with the concept of a "bit." Probably the best example of a bit is a light switch. The switch is either on or off, up or down, conducting electricity or not. Add a light, wires, and electricity, and a physical one-bit system is created.
The switch can be said to store one bit of information - information about whether the light is on or not. The wires convey that information to the light, which can be said to be a one-bit display device for the info.
Notice that one bit actually exists as TWO states, which can be named by any of many complimentary pairs of words or phrases, such as yes/no, on/off, there/not-there or, and here's a common one, one/zero. In fact, the name BIT is shortened from Binary digIT, which is a mathematical term for the one/zero state pair.
One light switch can only choose between up or down, but two are twice as plentiful in the number of states they can represent. They can both be up, both down, left up / right down, or vice-versa. Four states.
Add a single extra bit and the combinations double again, to eight. What if we multiply rather than add bits? Double 2 bits to 4 and the combinations quadruple to 16. Double again and the number is 256, a sixteen-fold increase. So the number of combinations which groups of bits can represent grows quickly as more bits are tacked on.
Four bits has a special name which is in most common use in industrial control: "nibble". The sixteen combinations is quite enough for many control applications. For example, sending a widget down that part of an automated assembly line which puts it in a box isn't all that complicated: slide into box - add glue - close lid - stamp serial number - etc. Four bits can be plenty of control for many simple operations.
Five bits have no special name, nor do six, nor seven, but eight bits are universally called a "byte". Besides being 8 bits, a byte is also a potential 256 combinations, more than enough to attach one unique encoding to each key on a computer or typewriter keyboard; letters, numbers, and punctuation, with plenty left over for various shifted pairs such as capital letters or control codes.
If the bit is the fundamental unit on which modern computer science is based, the byte is the derivative unit most important to commercial computing, mostly due to its close association with the alphabet.
Nine bits have no special name, nor do ten, but ten bits is a good place to look at counting. After all, computers compute, and counting is the most basic computation. Just as numbers can be expressed as combinations of the ten symbols 0 through 9 in our everyday "decimal" numbering system, they can also be expressed in a "binary" numbering system based on the two states of simple bits. That is, 0 through 1.
Since the binary system has only two symbols instead of ten, it takes more of them to express any given number. For example, three decimal digits can count up to 999. To express the same number in binary, it takes ten bits: 1111100111 (900 + 90 + 9, versus 512 + 256 + 128 + 64 + 32 + 0 + 0 + 4 + 2 + 1).
This approximate 3:10 ratio holds up for bigger numbers. For example, in a computer with a "megabyte of RAM" (one million bytes of memory), the system needs 20 bits to address them all, while the equivalent decimal number has barely "flipped over" to 7 digits (the actual number represented by 20 high bits is 1,048,575).
It's worth a reminder that in computer systems, the ones and zeros of the bits are represented by two different voltage levels. Different technologies use different voltages, but it all boils down to "high" and "low" volts being fed on wires into circuits designed to recognize and deal with those specific levels.
A note on the word "address:" this definition is very much the same as it is for streets, without the north, south, east or west. Starting at some zero point, the further one goes along a street, the higher the house numbers get. Memories start at address zero and grow from there, with a "house" with rooms for a certain number of bits (commonly but not always eight) at each higher address (none are skipped, as they may be on a city street).
So memories store bits which are in turn addressed by bits. All by themselves, memories can be used for computing. For example, a 256- byte memory array can be loaded with a pattern which can yield the result of multiplying any two four-bit numbers. The two numbers to be multiplied are concatenated into the eight bit address, and that address "looks up" the answer in the memory.
In this example, the largest result is only 15 x 15 = 225, but a wider memory (each address accessing more than the 8 bits of a single byte), coupled with more addressing, can multiply larger numbers. This is actually an extremely fast computing circuit, but the drawback is that as the numbers keep getting a little bit bigger, the memory space has to get a whole lot bigger. It doesn't take long for the necessary memory to become larger than it is possible to fabricate physically. The good news is that there are more powerful circuits than memories with which to compute.
The basic computer circuit is called a "gate." There are various kinds of gates of various sizes, but a gate can be as simple as two wires in and one wire out. One such circuit, known as an AND gate, can act as a 1-bit by 1-bit multiplier. The output of an AND gate is always zero unless its inputs are all ones, in which case the output switches to a one. Since 1 x 1 = 1, and 0 x anything = 0, a two-input AND gate does indeed multiply single bits correctly.
Returning to the four-bit example, a 4-bit by 4-bit multiplier only needs 16 simple AND circuits to perform the multiplication, instead of a memory array containing over 2,000 individual cells. Admittedly, there do have to be some adder circuits (built from a kind of gate other than ANDs) to sum up the AND-multiplication partial products, and these adders do of course take up room. But the important thing is that as the numbers get larger, the multiplication circuits built up from gates don't grow nearly as fast as memories must.
Extremely complex circuitry (known as combinatorial logic) can be built from rows of gates cascaded into other rows of gates, and this circuitry can be designed to do all sorts of different processing ("processing" being a more general term than "computing"), yet take up manageable space on an integrated circuit chip.
The idea of activity versus passivity is useful to hold in mind as one considers processing. Bits stored in memory arrays wait statically until they happen to be addressed, while bits introduced into gate arrays actively collide and combine into new patterns.
Processors usually run from "clocks," which are wires on which bits switch rhythmically between low and high and back again, each cycle acting as timing for groups of bits to go from passive storage through active processing and then either back into storage awaiting further cycles, or out into the human world: as answers to math problems or as codes to control machinery or as any other kind of output present-day computers produce.
Blocks of combinatorial logic circuitry can be cleverly designed to perform more than one function, each function being selected by its own special pattern of control bits. This begins to anticipate how the passive and active are mixed in modern digital systems. Memory doesn't only contain data such as letters or numbers, it also contains the control patterns for the circuits which will operate on that data. The same two numbers, for example, could be sent twice through the exact same logic circuit, yet be added the first time and subtracted the second, because in between times the bit pattern controlling the circuit has been changed.
Thus we finally arrive at programs: control instructions stored in memory and read out one by one as necessary to direct the internal computing machinery of a system. These programs are otherwise known as software; they exist, but not as hard physical objects one can see and touch.
The first commercial microprocessor was developed as an engine for use in electronic calculators. It moved around and operated on data in 4-bit chunks. To put it another way, it had a 4-bit word size, "word" being a generic term for the number of bits a processor deals with at one chunk.
This design was soon expanded to an eight bit processor, meaning its basic internal word size was a byte, which made it suitable for use in simple tasks like low-level industrial control and word processing. This micro quickly became so popular that better 8-bit designs were introduced, and the microcomputer industry was born, first as kits for hobbyists, and later as small home and commercial systems.
Eight is not enough, however, to be a truly efficient word size, neither for most useful units of data (eight bits can only count up through 255) nor for very powerful control encoding (2, 3, and even 4-byte instructions were common in these designs, necessitating multiple cycles to do a basic operation). So as soon as integrated circuit technology allowed, 16-bit architectures came out, followed by 32-bit and 64-bit designs as the '80s & '90s progressed. In previous years, both mainframe and minicomputer development had followed a similar growth path.
Even though the trend has been toward larger processors, it doesn't mean that the smaller word sizes are obsolete. In fact, one of the original 8-bit processors, the Z80, continues to sell more and more individual units annually even though it is now almost 20 years old. Different sizes fit different tasks. [Editor's note: haven't checked this fact for a few years... Editor's 2010 re-note: actually, the big winner in the 8-bit world turned out to be the 8051 family. Now their most common incarnations aren't as single chip units, but as "cores" embedded within, and controlling, other circuits sharing the same silicon. Billions of these are sold each year]
Nowadays, multiprocessing is common. In the leading-edge micros of this decade, lots is usually going on at one time. The central processing unit of the IC will be running some program, while on-board or on-chip coprocessors will be simultaneously doing other tasks such as managing memory or doing floating point calculations.
Multiprocessing, or parallel processing, can be coarse-grained, such as in a network of PCs wherein the unit of processing is a PowerPC or Pentium chip, or it can be fine-grained such that the average processor may consist of only a handful of gates. Digital signal processing ICs (DSPs) typically consist internally of such small units replicated many times over.
Though the processors have gotten bigger, they take up less and less space on a silicon wafer as miniaturization continues, and will continue, until it finally bumps into some law of physics. One current trend in processing technology is to combine more and more subsystems on a silicon die into a large, complex System-On-Chip (SOC). This is an outgrowth of older Application Specific Integrated Circuit (ASIC) technology, which was used for custom made-to-order logic devices. The more functionality that can be squeezed into a single package, the cheaper will be any product containing that package. Technology meets economics.