AKMA’s Random Thoughts

There's a Martin Buber moment lurking somewhere in here -- I-it relationships romanticized as I-thou -- but I am ever so not the right person to write about Martin Buber.

"The point of online interaction is not that it will replace physical interaction, but that the tenor of all our interactions will shift, has already shifted."

Since you're not really busy at this busiest of holiday seasons [wink-wink], I wonder if you could elaborate a bit on this particular assertion? For instance, what does "tenor" mean in this context? Who is included in the use of the possessive pronoun? What is the universe of interactions encompassed by "all"? And finally, what do you perceive is the "shift" (in "tenor") that has already occured, and is it the same as the "shift" that will occur? Is it possible for people to be unnerved about some aspects of the "shift," and exhilerated by others, or are there two clearly demarcated camps?

Sorry to be so particular, but it's hard to frame a reply unless I understand what you're trying to say.

Replacement panic is a good name and a useful concept. But haven't we heard it before...

"If the kids get to use pocket calculators, they'll never learn to do arithmetic."

"If we print too much of the service in the bulletin, people will never learn to use the prayer book."

"If we keep doing contemporary music, people will never learn the hymns."

"If we let the kids watch television, they'll never read books or play outdoors."

Seems like the telephone had the effect of putting (or allowing?) distance between people, allowing them to replace visits and letters with phone calls.

This back and forth is an important concept to understand in C programming, especially on the Mac's RISC architecture. Almost every variable you work with can be represented in 32 bits of memory: thirty-two 1s and 0s define the data that a simple variable can hold. There are exceptions, like on the new 64-bit G5s and in the 128-bit world of AltiVec

Note first that favoriteNumbers type changed. Instead of our familiar int, we're now using int*. The asterisk here is an operator, which is often called the "star operator". You will remember that we also use an asterisk as a sign for multiplication. The positioning of the asterisk changes its meaning. This operator effectively means "this is a pointer". Here it says that favoriteNumber will be not an int but a pointer to an int. And instead of simply going on to say what we're putting in that int, we have to take an extra step and create the space, which is what does. This function takes an argument that specifies how much space you need and then returns a pointer to that space. We've passed it the result of another function, , which we pass int, a type. In reality, is a macro, but for now we don't have to care: all we need to know is that it tells us the size of whatever we gave it, in this case an int. So when is done, it gives us an address in the heap where we can put an integer. It is important to remember that the data is stored in the heap, while the address of that data is stored in a pointer on the stack.

Earlier I mentioned that variables can live in two different places. We're going to examine these two places one at a time, and we're going to start on the more familiar ground, which is called the Stack. Understanding the stack helps us understand the way programs run, and also helps us understand scope a little better.

For this program, it was a bit of overkill. It's a lot of overkill, actually. There's usually no need to store integers in the Heap, unless you're making a whole lot of them. But even in this simpler form, it gives us a little bit more flexibility than we had before, in that we can create and destroy variables as we need, without having to worry about the Stack. It also demonstrates a new variable type, the pointer, which you will use extensively throughout your programming. And it is a pattern that is ubiquitous in Cocoa, so it is a pattern you will need to understand, even though Cocoa makes it much more transparent than it is here.

When the machine compiles your code, however, it does a little bit of translation. At run time, the computer sees nothing but 1s and 0s, which is all the computer ever sees: a continuous string of binary numbers that it can interpret in various ways.

A variable leads a simple life, full of activity but quite short (measured in nanoseconds, usually). It all begins when the program finds a variable declaration, and a variable is born into the world of the executing program. There are two possible places where the variable might live, but we will venture into that a little later.