On the web, the situation is quite simpler and more equal. Everybody were being fucked by Adobe Flash (and still are.) With occasional fingers thrust in by Windows Media and Apple Quicktime. All these have their own codecs (or variations of codecs) and all are proprietary. (If I had gods, I would thank them for making RealMedia defunct!)

But HTML5 has its own audio and video support, and HTML5 is being picked up by virtually every browser maker (yes, even Microsoft, but I can’t imagine why anybody still uses their piece of shit, except to download Firefox or Opera or Chrome or SeaMonkey or Safari. The really cool guys don’t even do that and FTP down the usable browsers directly!) The problem with HTML5 standard is that it doesn’t (didn’t?) mandate the container format and codecs (video or audio) that should be used! Obviously, this is not good for anybody. Of course, the situation could have been worse if the standard had specified a patent-laden or proprietary format, but still this under-specification means Morphy’s Law applies and web-developers and web site administrators get fucked even more than usual. Not to mention lusers.

A viable option for free audio and video was (and always is) of course Vorbis and Theora, and I quite like them, but people might argue that they (specially Theora) are not state-of-the-art codecs (not out-dated though, just not quite on the bleeding edge.)

Anyways, a few months back Google bought a company named On2 which held (presumably and hopefully) all the patents for a video codec (format) named VP8. At the time many people (including me) speculated and hoped that Google would put the patents in public domain (or whatever the term is that means make the use of the technology available to everyone, everywhere without charge and limitations for all time.) A couple of months back Google did the exact same thing and the WebM project was born. It’s defines a container format that hosts VP8 video and Vorbis audio, with no applicable patents in private control and liberal opensource-compatible licenses on all the software and libraries. Already most relevant browser makers have declared support for WebM (Mozilla, Opera, Google (obviously) and I think even Microsoft (but these days they just have to do anything the leaders of industry do, because they are not part of them anymore!)) and there are 3rd-party implementations of it. In short, I think the state of video on the web is starting to look good.

(This post has no links and it needs 100. I apologize for the inconvenience of having to copy+paste.)

In programming courses, one of the first examples used to introduce the idea of recursion is the Fibonacci sequence. You know, the series of integers starting with 0 and 1, where every next number is the sum of the two previous ones. (OK, I know that you do know. I was just covering all my bases.)

Anyways, the most simple and elegant introductory way of implementing a function that returns the nth number in the Fibonacci series goes something like this:

1
2
3
4
5
6
7

// Just making things clear!
typedef unsigned long long Integer;
 
Integer Fib (unsigned n)
{
	return n < 2 ? n : Fib(n - 2) + Fib(n - 1);
}

And every half-descent programmer knows that that’s probably one of the worst ways you can implement the idea. I’m not kidding. The teachers just throw this at the students, and the brighter of the students see the elegance and simple beauty of it and it will take years for most of them to realize the problems with this particular implementation. Some of them never do. This implementation performs very poorly for even the small values of n, which of course should be apparent when you contemplate its time complexity and recursion tree (I won’t go into space considerations, because they are not much of a problem until n goes into (many) thousands, at which point the value of the function becomes larger than you can store naively in most languages, which means you should have already given space considerations a serious thought.)

But even later, when the students learn about complexity analysis and Big O notation and crap like that, more often than not, they fail to apply the newly acquired knowledge to the old beliefs. If the teacher is good, and the student is bright and lucky enough, they walk out of their algorithm and data structure course with the new belief that bubble sort is bad, hash tables are good, and disk seek times dominate everything else (all of which are obviously bullshit in the absolute sense.)

For the more astute reader, I need to clarify that the badness of the mentioned implementation stems from the fact that most common languages (including C++) are mainly side-effect-driven languages, in that they rely mostly on the side-effects of expressions and statements to get the intended job done (the usage of the term “statement” is a clear sign of that.) Otherwise, you wouldn’t see so much assignment in our code. A functional and side-effect-free programming language (or more accurately, programming model) could easily cache the result of each invocation of the Fib function for any particular n (because the function call would be without side effects and therefore time-invariant) and would not need to evaluate any Fib(n) more than once. This is something that is being done in some of the better implementations of functional languages, AFAIK.

To emulate this behavior in this case, one can use a hand-coded version of what is known as Memoization, a la:

1
2
3
4
5
6
7
8
9
10
11
12

Integer Fib (unsigned n)
{
	static std::vector<Integer> Mem;
	if (n < Mem.size() && 0 != Mem[n]) return Mem[n];  // The second condition is redundant, right?
 
	Integer ret = n < 2 ? n : Fib(n - 1) + Fib(n - 2);
 
	if (n >= Mem.size()) Mem.resize (n + 1, 0);
	Mem[n] = ret;
 
	return ret;
}

This is not a bad implementation. It does have some issues in multithreaded applications, but I’m willing to overlook that for now. This implementation is linear in both time and space, and it can be faster than simple non-recursive implementations because it never calculates any Fib(n) more than once over the whole lifetime of the process. But it’s not pretty (it has its charms, though!) and this way of doing things is error-prone (because you are adding memory and bookkeeping to a mathematical construct that is otherwise free of this stuff.) Not to mention that it is basically impossible to use as an introductory example; because it needs knowledge from all over the map.

A better implementation might be:

1
2
3
4
5
6
7
8
9
10
11
12

std::pair<Integer, Integer> _fib (unsigned n)
{
	if (n < 2) return std::make_pair(n, 0);
 
	std::pair<Integer, Integer> Fn_1 = _fib(n - 1);
	return std::make_pair(Fn_1.first + Fn_1.second, Fn_1.first);
}
 
Integer Fib (unsigned n)
{
	return _fib(n).first;
}

Of course, the meat of this implementation (such as it is) is the _fib function. The other one is just there to present a nicer and more consistent interface. Let me be the first one to say that there are more ways to implement a better Fibonacci and still stay essentially recursive. This is just one way, and not a particularly great one. But it’s not bad either.

Now, how come no programming instructor ever teaches the likes of this implementation? Not the ones I studied under, at least. Are they afraid that their students’ heads are going to explode? PROGRAMMING IS HARD PEOPLE! If a programmer can’t handle a substantial improvement over a bad implementation of a simple idea, they are in for a big (and not at all nice) surprise. I hereby beg any teachers, instructors, professors and whatnot that have anything to do with teaching starting programmers to quit treating them like idiots, because idiots won’t make good programmers. The idiots are not going to understand what they need anyways, so why take the chance of profound understanding from those who have the capacity to learn, but might not if you treat them like babies?

For the sake of completeness, here’s a non-recursive implementation:

1
2
3
4
5
6
7
8
9
10
11
12
13

Integer Fib (unsigned n)
{
	if (0 == n) return 0;
 
	Integer last = 1, penultimate = 0;
	for (unsigned i = 1; i < n; ++i)
	{
		penultimate += last;
		std::swap (last, penultimate);
	}
 
	return last;
}

This is the fastest of implementations offered here, with the exception of the memoizing one (and only in amortized sense.) But nothing prevents us from applying the memoization technique to an iterative implementation as well, albeit not in a general and automatic way. It might not be apparent or significant in such a simple sample, but for some class of problems, recursive solutions are usually easier to devise and understand, and therefore easier to get right. In any case, nothing is clear-cut when it comes to programming, and I’m almost offended when people (specially people who should know better) behave as if almost everything is.

In other news, I have decided to drop Google Analytics usage on my blog; mostly as a statement in support of privacy activism. I really like Google, and most of the time they do the Right Thing, so I’m not really worried about them stockpiling and misusing our data. However, why should you guys (my less-than-a-handful of readers) trust Google with your data for my benefit?! That’s certainly an attitude I want other people to have toward me, so I’m gonna start from myself and scrap Google Analytics and I don’t think I would use any kind of 3rd-party user tracking system unless their handling and storage of the data is completely and provably secure, anonymous and temporary.

An obvious side effect of this is that I can no longer know how many people are reading my blog. I’d appreciate if you guys (I know there are at least two, so my sentence is syntactically and semantically correct) would be more active, comment-wise!

The presenter is Dr. Cliff Click, and the topic is an in-depth view of modern code execution architecture. The talk is from 2009, and it has been on my to{do} list for almost 6 months. It is the best thing I have seen in the last year (and I played God of War III!) if not in many years. The guy is obviously very knowledgeable and he talks extremely fast, which just means that he packs an incredible amount of invaluable information into this 50+ minute talk.

I can’t stress this enough. Take an hour to watch this. Please! If you are a game developer, or any programmer with a conscience, you have to watch it right now! I’m not kidding here. Watch this through.

On an ego-boosting note, I just watched this talk and I already knew almost all of it (I have to brush up on the newer cache-coherency protocols though; those have also been on my to{do} list for some time now!) It did have some eye-opening “Aha!” moments for me. I may write about them later.

What are you doing still reading my shithead rant?! GO WATCH THIS!Cliff Click’s Crash Course in Modern Hardware (hosted locally.)

I remember that I liked the language. It was clean and relatively compact, it had a largish and useful library, it was like C++ and Java (benefit? really?) and it had a command-line compiler. My impression at the time was that it was more suitable for small and quick programs, and very suitable for teaching programming. I even suggested it to my teachers at university as a replacement for Pascal, which was then thought as the first language to CE students (this was maybe 4 years before I met Lisp, or better yet, Python.) This was also before the whole .NET fucked-up-ness happened with all the WinForms and ASP.NET and whatever other shit they are peddling these days. In those days, .NET and C# produced console applications, unless you ventured into the river of diarrhea output that is the Win32 GUI API; but that was pretty much what you generally had, back then.

Anyways, my shallow and brief delving into the world of .NET was barely deep enough for me to familiarize myself with the inner workings of MSIL and the JIT compiler and the virtual machine. I learned little about these, and I have not kept up with the new developments in .NET, and I have no regrets there. I generally hate GUIs and network technologies that aim to solve all problems on all levels for everybody. They may suit some, and I have absolutely no doubt that many .NET-based applications wouldn’t have been as easy-to-write for other libraries and runtimes¹. But I don’t generally like .NET and this opinion (I suspect) would be very hard to change.

The most obvious reason for this obvious dislike is the one I mentioned above. .NET is the champion of the all-for-all thoughtcrime. More than anything else that I have seen, it tries to do all for everyone and everything; without giving them an inkling of what the hell is really going on on any level below the most superficial. This may suit some, but it shouldn’t.

I seriously believe that every programmer needs to know what’s going on under the hood. Total abstractions almost never work beyond the most simple and trivial cases². If you don’t know jackshit about your platform and your programs seem to have worked so far, you are just lucky. Let me give you an analogy. If you don’t know anything about how cars work and you drive one, when your cars breaks down in the middle of nowhere and you have no means of communication, the you are royally fucked. The fact that this has not happened so far, it just means that the Random Number Gods have smiled upon you so far. It may never happen, but it just as well might. That’s the way it is with programming. Except that the level of quality discrepancies among software and hardware products that you use is much wider.

All programming languages abstract the platform in some form and manner. But as some languages hide not much and what they hide, they do with much shame and much apologies (Assembly, C, etc.) others do as much as they can to distance you from the hardware. They even boast this feature!

In short, every good programmer that I know and I know of knows the whole stack of software and hardware underneath deeply and intimately. In fact, it might even be true that the better they know this mess, the better they are³.

Let me conclude now. I am not saying that technologies like .NET and Java and all those “high-level” languages are useless. I’m just saying they make it harder to be conscious about the actual platform and the rest that lies under your code. I’m pretty certain that the best .NET programmers can pretty much generate the MSIL code and the machine code that their compiler and the JIT compiler generate for any given part of their code. Maybe you should too.

How fucking twisted is that?! I’m actually rejoicing because we are going back to DLL Hell! But after experiencing the abyss of WinSxS Hell, I would happily crawl back to the open and only mildly tormenting depths of the good old DLL Hell. This means that I will (hopefully!) never ever have to mess around with ass-busting manifests and colossally subtle version conflicts and hunting down every single gods-damned version of every single fucking-gods-damned CRT component that might or might not have been subject to some whimsical patch by the morons at Microsoft in the past year, in one or other version of Windows. This means that I will just distribute the fucking version of the CRT that seems to barely work alongside my applications (that is, in the same directory) and it will probably (say 30% instead of 1e-10%) work, and no one will be able to override their usage behind the poor hapless user’s back (using conventional methods; that is. Everybody knows how easy it is to hijack a function call into a DLL in Windows; which I have to say is not necessarily a bad thing.)

And don’t anyone dare ask me why I link to CRT as a DLL in the first place, instead of a statically linked LIB!

P.S. I have decided to write as I think (regarding the usage of curse words.) So no more fraks and friggins and butts and backsides. Deal with it.

The reason’s for holding such an event is at least three-fold. First is to show how many talented artist live and work in Iran. Second is to get them into a challenge that will benefit all of them as they work towards a common goal with each other. The third one is to find a few really talented and driven modelers and persuade them to come and work with us on our upcoming projects!

Oh, I forgot to say that the first prize is a PS3 bundled with Uncharted 2: Among Thieves! (I wish I was a 3D artist! No one gives such prizes to game programmers!)

So, even if you are not interested yourselves, please spread the word around.

These dudes pretty much built the whole frakking Internet without the bureaucracy and the 3000-page conformance guidelines and the 2-million line test suit or the 12 years worth of committee meetings. Their procedures, and much more importantly their attitudes is quite concisely demonstrated in RFC 1025.

I had a perfect nightmare
on a starry torrid sea:

I am cast to prison at a
crippled demon’s plea.

The demon has 3 faces
all are laughing down at me.

The Banker with his filthy lucre
sets the game astride.

The General with raging might
lets forth a battle cry.

The Judge locks now the metal
tomb where I’m meant to die.

… But vengeance is
a brutal beast
not held by any cell

My wit is steeled
My blade is wet
So sound the Reaper’s bell.

Banker, General and Judge!
You all shall burn in Hell.

– From The Dishwasher: Vampire Smile‘s debut trailer.

Here I talk (mostly out of personal experience) about things that we should pay attention to, at the beginning of a game development project, so our debugging and issue tracking and solving experience becomes less irritating and more effective. I’d be happy to hear any suggestions, corrections and discussions.

Oh, and I have expanded the talk a bit, from what I actually presented! Also I’d be happy to explain my views on any of the particular points if anyone actually bothers to read through the thing.

The conference will be held on Esfand 19th and 20th (March 10th and 11th) somewhere inside SUT campus (yes, that’s tomorrow!)

My talk’s title is “Planning for Debugging Day” and in it I will present some thoughts and topics you should ponder and consider at the beginning of a game project to have less problems later on in the cycle when debugging, adding features, releasing, etc.

“Oh God!”
“Smith will suffice.”

Had I the heavens’ embroidered cloths,
Enwrought with golden and silver light,
The blue and the dim and the dark cloths
Of night and light and the half-light,
I would spread the cloths under your feet:
But I, being poor, have only my dreams;
I have spread my dreams under your feet,
Tread softly because you tread on my dreams.

This, of course, applies specially to the “Black Label”. However, only those who know what I’m talking about can possibly know what I’m talking about!

You look at human history, and almost every time there has been a war or oppression or genocide, it has had its roots in religion, in one way or the other. But, you might object, religion has brought happiness and peace of mind to billions. Well, while the extent of the happiness and the number of people affected by it is debatable, it can’t be denied that religious beliefs have been beneficial to many. But so has been the cartoons made by Disney! Have they not brought joy and happiness to hundreds of millions or perhaps billions, too? And there hasn’t been any wars or mass murders or tortures caused by a Walt Disney film. We must start analyzing the benefit/harm ratio of religions rationally.

So for some reason, among all the works of fiction it has been religion and religious materials that have gained special attention and have been given special status. Why? I don’t know. Maybe they have had more time with our collective brains to turn them into mush and turn us into brainless zombies. Maybe if you think about religion in terms of the theory of memes, it will become apparent that everything about a religion, specially the more widespread ones, is evolved with one most important purpose: to let it survive. That usually means spreading to as many people as possible. That means bringing people in and keeping them hooked up and destroying its rivals, be they other religions or science or whatnot. And we humans, have been the tools to be controlled by these vicious, dangerous and single-minded memes to ensure their survival.

If you think the purpose of any long lasting and popular religion is human happiness, you should think again. The purpose of any religion is its own survival and dominance. A few million people here and there doesn’t make much difference as long as the long-term success of that meme is guaranteed.

To those of you who still think, in this day and age, that any idea like religion should be enforced or even be allowed to be advertised or be a part of any government or ruling body, I can only say to look at history. Look at your own lives! Look at our own lives and the lives of those like us!

For those libertarians and agnostics among you, I have to say that I don’t think religion is something to be ignored and always categorized as a personal choice. Religion is harmful and dangerous. It’s not only publicly recognized dangerous religions and ideologies like Nazism that are dangerous, but the idea of any mass of humans controlled by any religion. We cannot afford to remain agnostic any more. People are entitled to their own beliefs of course, but those beliefs should never ever be the basis for special treatment or ever be let to come to power anywhere at any time.

P.S. I’m finally back in Tehran after a three-hour-plus flight delay.

In other news, I finally got my hands on the God of War Collection trailer. For those rare GoW-challenged people among my audience, the Collection is a remastered version of the first two God of War games for the PS3 (they where released for the PS2 originally.) It seems that, as they had promised, SONY has not changed anything in the games, and just packed some higher resolution textures and (maybe) animations, which is a wise move. The first two GoWs deserve to be preserve at the masterpiece of gameplay they are. This will be release this month.
Obviously, the above means I have to get my own PS3. As soon as I figure out a robust solution to get both video and audio out of the PS3 and into my 1080p-capable but HDMI-incapable monitor and my speakers, I’m taking the trip to the Toopkhuneh(!) square and getting me a 120GiB PS3 Slim.

In yet other news, late last month (a day before my own birthday in fact) the twelfth book in the amazing and fantastic fantasy series The Wheel of Time has been released. It was supposed to be in November too IIRC, which makes the release a nice surprise. I’m already a fourth into the book and I’m liking it! May Robert Jordan rest in pieces… oops!… rest in peace.
I have one thing to say to anyone who likes high fantasy at all: GO READ THE BOOKS. The whole 12000-13000 pages of pure immersion and greatness. Doesn’t matter what other people say. I have read enough fantasy series to know which one is great! Go read it. Read the first book if you feel you don’t have the time. Do yourself a favor.

It’s that damn Gates’ birthday again.

First, we all should know that new and delete are C++ operators, with all their facilities (and shortcomings, of course.) But not exactly like other operators, you can override them at a global level for every type that does not provide its own type-specific such operators. These global operators are provided as part of the C++ runtime library and are easily overridden. Their declarations are:

1
2
3
4
5
6
7

// The single-object versions
void * operator new (size_t mem_size);
void operator delete (void * mem_block);
 
// The array versions
void * operator new[] (size_t mem_size);
void operator delete[] (void * mem_block);

What new does is allocate a block of memory, and then call the constructor for the type with the address of the newly allocated block passed in as the this pointer. A delete call does the reverse; calling the destructor and then de-allocating the memory. The difference between the single-object versions and the array versions is only in the number of c’tor/d’tors they call. It amazes me how many C++ programmers don’t know and don’t care about details such as this (if you are programming in C++, these kind of details can and will bite you in the places you don’t want to be bitten!) If you fail to match them correctly, they allocate and de-allocate the correct amount of memory for the array or the single object, they just might not call constructors and destructors for all the objects being allocated or freed. That’s it.

Also, there is that small detail about exception-handling handling (yeah, two “handling”s!) The new operators may only throw an object of a sub-type of std::bad_alloc and only in the event that the requested amount of memory cannot be allocated. delete operators should never throw any exceptions (just like destructors. Remember that!) So, the correcter declaration for these operators would be:

1
2
3
4
5
6
7

// The single-object versions
void * operator new (size_t mem_size) throw (std::bad_alloc);
void operator delete (void * mem_block) throw ();
 
// The array versions
void * operator new[] (size_t mem_size) throw (std::bad_alloc);
void operator delete[] (void * mem_block) throw ();

Again, it is amazing how many programmers either don’t know about function exception specification and exception safety or just don’t use them (that includes me.) Of course, compiler providers are at least a little to blame here too. For example, Microsoft C++ compiler only distinguishes the empty exception list after a function declaration (meaning it doesn’t throw anything.) Anything else put there, just is taken to mean the default behavior is used (i.e. this function does throw something sometimes.)
In the meantime, the relationship between C++ programmers and exception handling remains in the love/hate/ignorance/hate/apathy/hate stage.

Later on, I’m going to talk abut overloading these global operators for fun and profit. Stay tuned!

Obviously, a related problem to memory management is calling the c’tor and d’tor for an object directly. Uses for this may not be immediately apparent, but as a few examples I could name implementing good smart pointers, memory pools, memory managers, garbage collectors, generic object containers (e.g. std::vector) and such.
You probably already know how to call the destructor on an instance directly. If you have a pointer x to an object of type T, you can call its d’tor like this: x->~T() (note that you should not generally call the d’tor in this way, unless you yourself have called the c’tor directly on that instance as well.) Calling the constructor is a bit trickier though (not really; I’m just being foreboding!)

What you should realize is that you can overload new and delete with different signatures that the ones above. You can add arguments and of different types. There are a few other signatures for these two provided by the standard C++ library (yeah, there are others!) The less interesting of them are:

8
9
10
11
12

void * operator new (size_t mem_size, std::nothrow_t const & please_dont) throw ();
void operator delete (void * mem_block, std::nothrow_t const & please_dont) throw();
 
void * operator new[] (size_t mem_size, const std::nothrow_t & please_dont) throw ();
void operator delete[] (void * mem_block, std::nothrow_t const & please_dont) throw();

Forget about the deletes for a minute. The additional parameters to the new calls above are actually not used inside of the functions. Any object of type std::nothrow_t will suffice as the second parameter; it will be there just to signal the compiler to use this particular overload of the operator, which doesn’t throw any exceptions whatsoever. I just need to emphasize again that the regular new never returns a NULL pointer. It just throws an exception. But this one returns a 0 pointer upon failure and never throws anything, being it rocks, shoes or exceptions. The syntax for calling them, as you might suspect, is peculiar:

13
14
15
16
17
18
19
20

#include <new>  // for std::nothrow
//...
T * p = new (std::nothrow) T (/* usual constructor parameters */);
// The line above calls a particular "new" overload with two
// parameters: a size_t and a std::nothrow_t.
// Oh, and std::nothrow is just an object of type std::nothrow_t.
//... 
delete p;

Notice that I didn’t call the delete with any extra parameters or anything. In fact, there is no syntax in C++ for calling delete with any parameters! Besides, delete is already a non-throwing function. So what gives?! Why is there a paired delete for every frakking new when there is no frakking way of calling them?! You should keep your cool. I may explain them (if you don’t already know,) or we can leave the subject as an exercise. I would just say that the paired delete is called by the code generated by the compiler in a very specific situation.

Note that anything other than the straightforward, unary new and delete is called a “placement new/delete“. However, I’ve heard the term be used for a specific overload, which is more interesting and looks like this:

21
22
23
24
25

void * operator new (size_t mem_size, void * mem_ptr) throw ();
void operator delete (void * mem_block, void * mem_ptr) throw ();
 
void * operator new[] (size_t mem_size, void * mem_ptr) throw ();
void operator delete[] (void * mem_block, void * mem_ptr) throw ();

The implementations for the above operators are really simple. Here’s a complete listing:

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

void * operator new (size_t mem_size, void * mem_ptr) throw ()
{
    return mem_ptr;
}
 
void operator delete (void * mem_block, void * mem_ptr) throw ()
{
}
 
void * operator new[] (size_t mem_size, void * mem_ptr) throw ()
{
    return mem_ptr;
}
 
void operator delete[] (void * mem_block, void * mem_ptr) throw ()
{
}

Note that although I haven’t written it, the constructor and destructor calls happen outside of my control. These versions of new and delete are used when we don’t want to allocate or free any memory, and just want the constructors and destructors to be called. For new, we just pass in a pointer to another sufficiently-sized memory location and ask the compiler to generate the code to call the c’tor upon that area of memory. That’s how we call a c’tor directly. We procure some memory area from somewhere and use that, like this:

43
44
45

T * x = (T *)malloc (10 * sizeof(T));
for (unsigned i = 0; i < 10; ++i)
    x[i] = new (x + i) T (/*usual c'tor params. */);

These standard placement operators cannot be hidden or overridden in user code, but there is still a ton of fun to be had.

You can very easily replace the old, simple and default operators with an implementation of yours, a la:

46
47
48
49
50
51
52
53
54
55
56
57
58
59

void * operator new (size_t mem_size)
{
    void * ret = malloc (mem_size);
    if (0 == ret)
        throw std::bad_alloc ();
    return ret;
}
 
void delete (void * mem_block)
{
    free (mem_block);
}
 
// the array versions are exactly the same

As I have stated earlier, the c’tor/d’tor calls are generated automatically for you by the compiler. So now you are free to write your own memory manager!

The way that memory manager/debugger/helper/whatevers usually work under the hood is that they allocate more memory than you have requested, and put their own junk right before and/or right after the area that gets passed back to the user (that’s a bad way to do memory management, but that one is a long story.) Some of the stuff that are usually kept there include a pointer to the next and/or previous allocated block of memory (so all the blocks form a linked list,) sentinel values right before and right after the user area to detect buffer overruns (e.g. 0xdeadbabe,) the size of the memory block, the code file/line/function/module that allocated this particular block and so on and so forth. Actually, your default memory manager in the CRT is doing this right now. Just new two large-enough blocks of memory and compare their address differences with the size of the first block. The runtime accompanying some compilers (like VC++) even exposes their internal data structures and means to work with the memory manager (although rather passively.)

You need to keep in mind though, that what I have discussed so far barely scratches the surface of writing memory managers. These are just practicalities and implementation details; the state of the art on the theory of the matter and memory allocation algorithms, policies and mechanisms can fill several books. Even on the implementation side, there are really serious issues with performance, cache-friendliness, thread-safety, multiple thread support, etc. need taking care of.
Besides, much (if not most) of the memory (de)allocation going on in a C++ program these days go through C or operation system API, shared object files (DLLs,) through third part code or through STL, all of which bypass the basic technique discussed above. So, if you really are serious, you should investigate the existing memory debuggers or memory leak detectors or memory managers. There are several open source ones out there, with various degrees of sophistication and complexity. Have fun! (But for what it’s worth, I should mention that we have used a memory leak detector using nothing but this technique in Garshasp and a similar project before, and in both projects it has been a great help.)

Try reading the following with a picture of Darth Vader in front of you, his voice booming in your head, and preferably with a red-blade Light Saber replica on your mantelpiece (sorry folks, I really do have one of these!)

You are sure [...]?

…Leave him alone.

We want you to use her blood.

Who is that man?!

My own son…

Inject my IV with an air bubble. I will have another heart attack and no one will know. [...] You were trying to put a gun in his hand and point it at my head. The gun is now in your hand. That is a practical difference, not a moral one.

In my world there are dangers and bloodshed and death, and that makes you a man. And men make choices.

I just finished watching this 3rd episode of season 6 and it was a good one.

P.S. OK, that’s no way to come back and post to my blog after a few months, but give me a break; I’m trying to ease in (you know, 2x³-3x² style!)

If you thought that was the rant, you’re sourly mistaken. Here it is.

Let’s try a thought experiment. Nothing real, just a wild and fantastical fantasy. Suppose you are standing on the edge of a rooftop, contemplating jumping down. As long as you haven’t jumped, the choice is always yours. You can jump, stay on the edge or move back. It’s not like you can’t jump two seconds or two hours later. If the situation changes, you can always weigh the odds again and make a more suitable choice.
But what if you jump? You make a choice and you jump. I think that’s the best choice you can make; the most logical. If you stay on the edge, or you move back, the edge and the jump will always be there, tempting and tantalizing. Why defer the choice?
Some might say because it’s a final choice and because you will always have the option, you can postpone it for later. It’s not like the edge is going anywhere, right? Wrong. I say you should always jump the first chance you get, because once you jump, there is no going back and there is no more choices. Why would you postpone a move that solves your dilemma so quickly? How come people (including myself) defer such obviously logical choices for more than a single second?
I like these kind of choices. I like changes and commitments that you cannot revert. They simplify life so much.

I think it’s kind of funny, I think it’s kind of sad,
The memories in which I’m dying are the best I’ve ever had.

That’s not about death of course. It’s about giving up in despair. It’s about indecision and inability to deal. It’s about petty problems that prove impossible for weak people.
It’s about me.

Justice Is Lost
Justice Is Raped
Justice Is Gone…

…And no justice for all, because a bunch of petty, raisin-brained dictator-wannabes wanna be dictators. And frak them all.

Frak. Frak. Frak. Frak me sideways.

I, like most of us, am worried about where we are headed. I, like most of us, am skeptical about the election results and whether it’ll have a real impact for the better. I don’t think anyone has any doubts about whether the times can get worse, because they sure can, as the past four years have shown. But for the better? I don’t know.

However, like many stupid young people, I have my hopes. I hope for for a more realistic government. One that is more in line with what the people want and need. You know what? I want a less stupid government. One that does not tell so many lies that even its own body starts believing them.

I hope for less religious mumbo jumbo and more information and wisdom. I want a government that works efficiently and knowledgeably and let’s people do whatever they want as long as they don’t break the law. And I want real, realistic and usable means to change the laws if they are broken and bad.

I want freedom. I want a government that is afraid of its people, not a people that are afraid of their government even when they are in their own bed. Even worse, I don’t want a people that don’t care about their government as long as it doesn’t step on their toes and vice versa.

I want people to listen to each other. I want people not to turn their head and pretend that they just don’t see. I don’t want the stupid idiots who decide my fate to still think that what is said in some book from several hundred years ago is absolute truth, no matter how strange, immoral, improbable, unacceptable, malicious and unscientific it is.

I don’t want my government officials to say that they do their job because some god says so in some book, or because it’s their religious obligation, or because some guy who died 1300 years ago is quoted to have wanted so.

I want them to do their job because the law says so, or because it’s their moral, social or logical obligation, or because the people want so.

I want some information. I am sick and tired of being treated like an idiot. I want freedom of the press and media. I know it’s got its own bag of problems, but hey, that’s much better than what we got already: all the problems of a media-driven and media-blinded society and 2% the functionality.

I want science and knowledge to have real value, not just as things to do in university as a way to pimp up your resumé to get the hell out of this dismal country. I want the wheels of industry, commerce, trade and technology to start turning and to move this country forward.

I want an education system that instead of force feeding children with crap and filling their heads with superstition and guilt and unreal notions of hope and salvation, teaches them to think and choose and provide them with data to support their choice. I want our schools to be playgrounds for the real world out there, not 11 years (or 12 or whatever the number currently is) of isolation from reality and Newspeak practice. I don’t want teenagers to learn more from ditching school than attending.

I want people to panic! I don’t want us to go about our lives like sheep the night before they are slaughtered, or like the anecdotal frog that never jumps out of the water that is slowly starting to boil. Our situation is very dire. I want to see people start screaming out of their windows that they are “mad as hell” and that they are “not going to take it anymore.” Why no one does that, unless it’s election time and they are one of the candidates and preferably there are more than three million watching?

On days like these, why it is that I find the immortal songs of Mr. Bob Dylan to be the ones that speak most loudly my heart and mind?

Do times ever change? Am I a fool to hope? Am I a simpleton to be knocking on heavens door? In days like these, I feel like my hopes, and most people’s, are blowing in the wind.

شنیده‌ام که گور جای خوب و خلوتی‌ست
ولی کسی در آنجا تو را در آغوش نخواهد گرفت