The Pattern on the Stone Quotes

“More recently, a new generation of languages has begun to emerge. These languages—Small-Talk, C++, Java—are object-oriented. They treat a data structure—for instance, a picture to be drawn on the screen—as an “object” with its own internal state, such as where it is to be drawn or what color it is. These objects can receive instructions from other objects. To understand why this is useful, imagine that you are writing a program for a video game involving bouncing balls. Each ball on the screen is defined as a different object. The program specifies rules of behavior that tell the object how to draw itself on the screen, move, bounce, and interact with other objects in the game. Each ball will exhibit similar behavior, but each will be in a slightly different state, because each will be in its own position on the screen and will have its own color, velocity, size, and so forth.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Another example is the definition of a palindrome, which we can define as follows: A word is a palindrome if it has less than two letters (the simple case) or if its first and last letter are the same and the letters in the middle form a palindrome (the recursive step). The simplest way to write a Logo program for recognizing palindromes would be to use this recursive definition.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“This kind of recursive definition with a changing parameter is useful for producing anything that has a self-similar structure. A picture that contains a picture of itself is an example of a recursive, self-similar structure; such structures are commonly known as fractals. In the real world, self-similar structures don’t go on forever: for instance, each branch of a tree looks a lot like a smaller tree, and each of these smaller branches has branches that look like still smaller trees. This recursion goes on for several levels, but eventually the branches are so small that they do not have branches of their own.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“It will not halt until it is interrupted—an example of a common sort of program behavior called an infinite loop. Programmers often create infinite loops accidentally, and (as we shall see) it can be extremely difficult to predict when such loops will occur.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“One of the tricks that Logo-using children discover is that they can insert a word inside its own definition, a practice known as recursion. For instance, a child might generate a circular design consisting of many rotated squares, as follows: TO DESIGN SQUARE RIGHT 10 DESIGN END”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Once the word “square” has been defined, it becomes part of the computer’s vocabulary and can then be used to define other words. For example, TO WINDOW SQUARE SQUARE SQUARE SQUARE END Each square will be drawn in a different place, because the procedure for drawing the square leaves the turtle rotated 90 degrees. In computer terms, SQUARE is a subroutine of the program WINDOW, which calls it. The subroutine SQUARE, in turn, is defined using the primitives FORWARD and RIGHT. User-defined words in Logo can take parameters, too. For instance, a child can specify various sizes of square by specifying what parameter determines the length of each side.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“If the child types the command FORWARD 10, the turtle takes ten steps forward—that is, upward—drawing a line ten units long. The number 10 following the FORWARD command is called a parameter; in this case, the parameter tells the turtle how many steps to take.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Logo is also an extensible language—that is, you can use Logo to define new words in Logo.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Each language has its own syntax. You need to learn the syntax in order to write the language, but (like spelling and punctuation in a human language) syntax is not fundamental to the meaning or the expressive power of the language. What is important to the expressive power of the language is the vocabulary—the so-called primitives of the language—and the way the primitives can be combined to define new concepts. Programming languages describe the manipulation of data, and one way in which these languages differ is in the kinds of data they can manipulate. The earliest computer languages were designed primarily to manipulate numbers and sequences of characters. Latter-day programming languages can manipulate words, pictures, sounds, and even other computer programs. But no matter what sort of data the language is designed to handle, it typically provides a way of reading the data’s elements into the computer, taking the data apart, putting them together, modifying them, comparing them, and giving them names.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“As powerful as they are, finite-state machines are not capable of recognizing all types of patterns in a sequence. For instance, it is impossible to build a finite-state machine that will unlock a lock whenever you enter any palindrome—a sequence that is the same forward and backward, like 3–2–1–1–2–3. This is because palindromes can be of any length, and to recognize the second half of a palindrome you need to remember every character in the first half. Since there are infinitely many possible first halves, this would require a machine with an infinite number of states.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The methods I’ve described can be used to implement any function that stays constant in time, but a more interesting class of functions are those that involve sequences in time. To handle such functions, we use a device called a finite-state machine. Finite-state machines can be used to implement time-varying functions—functions that depend not just on the current input but also on the previous history of inputs. Once you learn to recognize a finite-state machine, you’ll notice them everywhere—in combination locks, ballpoint pens, even legal contracts. The basic idea of a finite-state machine is to combine a look-up table, constructed using Boolean logic, with a memory device. The memory is used to store a summary of the past, which is the state of the finite-state machine.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“many computers use a slightly different convention for representing negative numbers and also have a convention called a floating point to represent numbers that have decimal points. (The position of the decimal point “floats” relative to the digits, so that a fixed number of digits can be used to represent a wide range of numbers.) The particular representation schemes are often chosen in such a way as to simplify the logic of the circuits that perform arithmetical operations, or to make it easy to convert from one representation to another.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Computers can use combinations of bits to represent anything; the number of bits depends on the number of messages that need to be distinguished. Imagine, for example, a computer that works with the letters of the alphabet. Five-bit input signals can represent thirty-two different possibilities (25 = 32). Functions within the computer that work on letters sometimes use such a code, although they more often use an encoding with seven or eight bits, to allow representation of capitals, punctuation marks, numerals, and so on. Most modern computers use the standard representation of alphabet letters called ASCII (an acronym for American Standard Code for Information Interchange). In ASCII, the sequence 1000001 represents the capital letter A, and 1000010 represents the capital B, and so on. The convention, of course, is arbitrary.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Most computers have one or more conventions for representing numbers. One of the most common is the base 2 representation of numbers, in which the bit sequence 0000000 represents zero, the sequence 0000001 represents the number 1, the sequence 0000010 represents 2, and so on. The description of computers as “64-bit” or “32-bit” indicates the number of bit positions in the representation used by the computer’s circuits: a 32-bit computer uses a combination of thirty-two bits to represent a base-2 number.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The great thing about the method described is not that it produces the best implementation but that it always produces an implementation that works. The important conclusion to draw is that it is possible to combine And, Or, and Invert blocks to implement any binary function—that is, any function that can be specified by an input/output table of 0’s and 1’s.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“And blocks are used to detect each possible combination of inputs for which the output is 1, while Or blocks provide a roster of these combinations”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“we don’t really need And blocks in our universal building set, because we can always construct them out of Or blocks and Inverters.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“For a binary function with n inputs, there are 2n possible combinations of input signals.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The logic blocks And, Or, and Invert form a universal construction set, which can be used to implement any set of rules. (These primitive types of logic blocks are sometimes also called logic gates.)”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“This hierarchical structure of abstraction is our most powerful tool in understanding complex systems, because it lets us focus on a single aspect of a problem at a time. For instance, we can talk about Boolean functions like And and Or in the abstract, without worrying about whether they are built out of electrical switches or sticks and strings or water-operated valves. For most purposes, we can forget about technology. This is wonderful, because it means that almost everything we say about computers will be true even when transistors and silicon chips become obsolete.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Naming the two signals in computer logic 0 and 1 is an example of functional abstraction. It lets us manipulate information without worrying about the details of its underlying representation. Once we figure out how to accomplish a given function, we can put the mechanism inside a “black box,” or a “building block” and stop thinking about it. The function embodied by the building block can be used over and over, without reference to the details of what’s inside. This process of functional abstraction is a fundamental in computer design—not the only way to design complicated systems but the most common way”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“the implementation technology must produce perfect outputs from imperfect inputs, nipping small errors in the bud. This is the essence of digital technology, which restores signals to near perfection at every stage. It is the only way we know—at least, so far—for keeping a complicated system under control.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The analogy between water valves and transistors is so exact that you could translate the design for a modern microprocessor directly into a design for a hydraulic computer. To do so, you would need to look at the pattern of wires on the silicon chip under a microscope and then bend a set of pipes into the same shapes as the wires on the chip and connect them in exactly the same pattern. In place of each transistor, you would use a hydraulic valve. The pipe that corresponds to the power-supply voltage on your chip would be connected to a pressurized water supply, and the pipe that corresponds to the ground connection could empty down a drain.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“This type of design is called restoring logic, and the example in hydraulic technology is particularly interesting, because it corresponds almost exactly to the logic used in modern electronic computers. The water pressure in the pipes is analogous to the voltage on the wires, and the hydraulic valve is analogous to the metal-oxide transistor. The control, input, and output connections on the valve correspond closely to the three connections (called gate, source, and drain) on a transistor.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“This is the fundamental difference between digital and analog: A digital valve is either on or off; an analog valve, like your kitchen faucet, can be anything in between. In the hydraulic computer, all that is required of the input signal is that it be strong enough to move the valve. In this case, the difference that makes a difference is the difference in water pressure sufficient to switch the valve on. And since a weakened signal entering an input will still produce a full-strength output, we can connect thousands of layers of logic, the output of one layer controlling the next, without worrying about a gradual decrease in pressure. The output of each gate will always be at full pressure.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“Notice that in a hydraulic valve the control pipe can affect the output pipe but the output pipe cannot affect the control pipe. This restriction establishes a forward flow of information through the switch; in a sense, it establishes a direction in time. Also, since the valve is either open or closed, it serves an additional function of amplification, which allows the strength of the signal to be restored to its maximum value at every stage.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The picture I have in my mind when I design a logic circuit is of hydraulic valves. A hydraulic valve is like a switch that controls and is controlled by the flow of water. Each valve has three connections: the input, the output, and the control. Pressure on the control connection pushes on a piston that turns off the water flow from input to output.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“These And, Or, and Invert functions are logic blocks, and they can be connected in order to create other functions. For instance, the output of an Or block can be connected to an Invert block to create a Nor function: the Nor output will be a 1 when neither of its inputs is 1. In another example (using De Morgan’s theorem), we can make an And block by connecting two Invert blocks to the inputs of an Or block and connecting a third Invert block to the output (see Figure 6). These four work together to implement the And function, so the final output is 1 only when both the inputs are 1.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“The computer represents numbers, letters, and everything else with patterns of bits.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work

“A signal that can carry one of two different messages (like 1 or 0) is called a binary signal, or a bit.”
― William Daniel Hillis, The Pattern on the Stone: The Simple Ideas that Make Computers Work