AKMA’s Random Thoughts

My tuition bills are laid out in two columns, one for the money I owe them, and one for the credits I've received from grants, loans, waivers, etc. And there are usually extra numbers that could possibly belong to either column, so it's an exciting surprise when I go to the finance office and ask, 'What does this mean to me?'

Someone in financial aid learned the torture techniques from Wealth Bondage, without the humanist outrage.

Medical bills. I HATE dealing with fee-for-service medical bills.

The hospital charges $X for a room. The insurance company has a negotiated fee of $X/6. They pay 90% of that, thank goodness. I about croaked when I saw the original $X charge.

And sometimes the only way to determine the correlation between the items on the bill and the items on the insurance is to compare the dollar amounts. Sometimes even that doesn't work.

Then there are corporate "restructuring charges". I think those are amounts that a company expects to spend on some change (layoffs, lease terminations, etc.) It's not a real expenditure yet, but they count it now, so they don't have to count it later. I've even seen companies that later realized a gain because they spent less than expected.

Then there's Enron. 'Nuff sed.

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.

Let's see an example by converting our favoriteNumber variable from a stack variable to a heap variable. The first thing we'll do is find the project we've been working on and open it up in Project Builder. In the file, we'll start right at the top and work our way down. Under the line:

Each Stack Frame represents a function. The bottom frame is always the main function, and the frames above it are the other functions that main calls. At any given time, the stack can show you the path your code has taken to get to where it is. The top frame represents the function the code is currently executing, and the frame below it is the function that called the current function, and the frame below that represents the function that called the function that called the current function, and so on all the way down to main, which is the starting point of any C program.

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 Stack is just what it sounds like: a tower of things that starts at the bottom and builds upward as it goes. In our case, the things in the stack are called "Stack Frames" or just "frames". We start with one stack frame at the very bottom, and we build up from there.

To address this issue, we turn to the second place to put variables, which is called the Heap. If you think of the Stack as a high-rise apartment building somewhere, variables as tenets and each level building atop the one before it, then the Heap is the suburban sprawl, every citizen finding a space for herself, each lot a different size and locations that can't be readily predictable. For all the simplicity offered by the Stack, the Heap seems positively chaotic, but the reality is that each just obeys its own rules.