To the MSNBC & GE commentators, a special delivery response-poem by Jack Mapanje:

On His Royal Blindness Paramount Chief Kwangala

I admire the quixotic display of your paramountcy
How you brandish our ancestral shields and spears
Among your warriors dazzled by your loftiness
But I fear the way you spend your golden breath
Those impromptu, long winded tirades of your
might
In the heat, do they suit your brittle
constitution?

I know I too must sing to such royal happiness
And I am not arguing. Wasn't I too tucked away
in my
Loin-cloth infested by jiggers and fleas before
Your bright eminence showed up? How could I
quibble
Over your having changed all that? How dare I
when
We have scribbled our praises all over our graves?

Why should I quarrel when I too have known mask
Dancers making troubled journeys to the gold mines
On bare feet and bringing back fake European
gadgets
The broken pipes, torn coats, crumpled bowler
hats,
Dangling mirrors and rusty tin cans to make their
Mask dancing strange? Didn't my brothers die
there?

No, your grace, I am no alarmist nor banterer
I am only a child surprised how you broadly
disparage
Me shocked by the tedium of your continuous
palaver. I
Adore your majesty. But paramountcy is like a
raindrop
On a vast sea. We should not wait for the
children to
Tell us about our toothless gums or our showing
flies.

Seth Roby graduated in May of 2003 with a double major in English and Computer Science, the Macintosh part of a three-person Macintosh, Linux, and Windows graduating triumvirate.

When compared to the Stack, the Heap is a simple thing to understand. All the memory that's left over is "in the Heap" (excepting some special cases and some reserve). There is little structure, but in return for this freedom of movement you must create and destroy any boundaries you need. And it is always possible that the heap might simply not have enough space for you.

The rest of our conversion follows a similar vein. Instead of going through line by line, let's just compare end results: when the transition is complete, the code that used to read:

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.

Inside each stack frame is a slew of useful information. It tells the computer what code is currently executing, where to go next, where to go in the case a return statement is found, and a whole lot of other things that are incredible useful to the computer, but not very useful to you most of the time. One of the things that is useful to you is the part of the frame that keeps track of all the variables you're using. So the first place for a variable to live is on the Stack. This is a very nice place to live, in that all the creation and destruction of space is handled for you as Stack Frames are created and destroyed. You seldom have to worry about making space for the variables on the stack. The only problem is that the variables here only live as long as the stack frame does, which is to say the length of the function those variables are declared in. This is often a fine situation, but when you need to store information for longer than a single function, you are instantly out of luck.