AKMA’s Random Thoughts

try http://www.fontlover.com, which was where I found Nick's fonts.

Thanks, Elaine. I do stop by fontlover from time to time, but he doesn’t update as often as I’d like, and includes (for entirely justifiable reasons) for-pay typefaces, which I just can’t afford. So I’ll continue dropping by there, but will only report here on freeware.

Type faces and fonts

What do you do with them?
How does one use them?

If I don't have the type you use will I see your font or type face?

This sounds silly to those of you who are into fonts but I really don't understand how one uses the custom fonts. If you get a chance can you let us know.

Came here to say Happy New Year to you and your family. Peace to all of us in 2003.

meg,

I don't know just what to do with typefaces on PCs. I don't use out-of-the-ordinary type for web design (except in images), since you point to the vexing problem that we may not have the same typefaces installed and usable, and my repertoire depends upon your choices.

I do use various typefaces in designing printed pages for my academic work. I use a different combination of body and display faces for each term of each class, which helps me remember how to group things--and, let’s be candid, brings me pleasure.

My favorite linguistics professor had a small disquisition in his syllabus on typefaces for use in papers. This is Times Roman. This is Palatino. This is [ some thoroughly bizarre effect font ], and if you use this you are in Big Trouble.

Well, I giggled.

This code should compile and run just fine, and you should see no changes in how the program works. So why did we do all of that?

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.

Let's take a moment to reexamine that. What we've done here is create two variables. The first variable is in the Heap, and we're storing data in it. That's the obvious one. But the second variable is a pointer to the first one, and it exists on the Stack. This variable is the one that's really called favoriteNumber, and it's the one we're working with. It is important to remember that there are now two parts to our simple variable, one of which exists in each world. This kind of division is common is C, but omnipresent in Cocoa. When you start making objects, Cocoa makes them all in the Heap because the Stack isn't big enough to hold them. In Cocoa, you deal with objects through pointers everywhere and are actually forbidden from dealing with them directly.

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.

This is another function provided for dealing with the heap. After you've created some space in the Heap, it's yours until you let go of it. When your program is done using it, you have to explicitly tell the computer that you don't need it anymore or the computer will save it for your future use (or until your program quits, when it knows you won't be needing the memory anymore). The call to simply tells the computer that you had this space, but you're done and the memory can be freed for use by something else later on.

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