Okaaaaayyyyyy……

But I really do get sucked into things and lose track of time. I’m really terrible about that.

Oh well! Back to the grind stone! My latest project is just learning the fundamentals of GUI programming. SDL does not support OpenGL 4, and I was have a hard time picking a different windowing library, so I decided to go back to basics. Right now I writing a simple (very simple!) framework using xlib. After that I’ll do the same on Windows. Once I have a grasp of the basic concepts on both platforms, then I should be better positioned to understand the strengths and weaknesses of the available libraries.

#include <stdio.h>

main()
{
  printf("goodbye, world");
}
 

So long, Dennis! We’ll miss you!.

Can you say “old school” children? The game play video looks great! They seem to have really captured the spiritl of the old classics, like Ultima Underworld and Wizardry. I hope this turns our well. I certainly know that I’ll be keeping an eye on it!

Steve Jobs, the pioneer of the computer as a jail made cool, designed to sever fools from their freedom, has died.

As Chicago Mayor Harold Washington said of the corrupt former Mayor Daley, “I’m not glad he’s dead, but I’m glad he’s gone.” Nobody deserves to have to die – not Jobs, not Mr. Bill, not even people guilty of bigger evils than theirs. But we all deserve the end of Jobs’ malign influence on people’s computing.

Unfortunately, that influence continues despite his absence. We can only hope his successors, as they attempt to carry on his legacy, will be less effective.

Apparently some people now think Stallman should resign from the FSF over this. That might be appropriate if not for one thing: Stallman is right. Steve Jobs was a great businessman and he had an eye for good technology, but by training people to accept restrictions on their freedom as a pre-condition of using computers, he has set back the cause of civil liberties on the Internet, and I simply see no reason to forgive him for that.

Apple frequently bans apps from the iPhone for political and religious reasons.

Banned iPhone Apps: 15 Most Outrageous Rejected Apps
The 9 Most Controversial Apps Censored By Apple

They also like to ban anything that let’s you program the computer, or emulate other computers, both activities that are fundamental to software freedom.

Command Line for iPhone
Retro on your phone: Android users get C64 emulator, while similar app gets banned on iPhone

Google’s Android is now following Apple’s lead, too, so it’s no use saying “the market will provide a solution”. People have been trained to accept limits on their freedom, and it’s now virtually impossible to find a smart phone maker that actually respects your right to privacy and to control your own computers.

Thanks, for giving the world such a terrible gift, Steve. I’m sorry you died from such a terrible disease, and my sympathy goes out to your family and friend. I, though, will mourn the lost opportunities. You turned your brilliant mind to inventing new ways to control people, rather than trying to free them. You became, Big Brother, Steve. And just like Winston Smith, we loved you.

But we won’t miss you.

The game is a series of dreams being had by a young woman who is in the hospital recovering from a serious car accident. Like real dreams, they can be repetitive and monotonous. Also like real dreams, each one can have moments where a bit of the imagery from a different dream peeks through. (Keep this in mind as you play. If you get stuck, go have a different dream and you may find the clue you need for the first one.)

Again like real dreams, each sequence seems to hold symbolism whose meaning you just can’t quite pick out. Sure, there are obvious messages, such as over-protective parents pushing you in directions you might not want to go, But seeds of life that become overwhelming burdens instead? Things never seem to work out how you intended them too, but this imagery leaves me with a nagging feeling that I’ve missed something. I expect I have.

In the end of the game, the memory of the dreams becomes just that – just a memory – and your character goes back home to her apartment to pick up her life where she left it, but with a gnawing feeling of dissatisfaction. Much like my own weekend, actually. I went into the weekend with the intention of working on a piece of code I’ve been writing, but instead I ended up doing other things, some useful, some not. Laundry. Grocery shopping. Reading (Game Programming Gems and The Mythical Man Month). In the end I wrote no code. I didn’t even look at it!

And now it’s back to work for another exciting week of fixing broken websites.

I think the most unnerving thing about Trauma is that it left me with the same feeling that I actually have when I reflect on my own dreams and aspirations.

To users of the Boost libraries, this will be old hat, but to me its quite new and exciting. shared_ptr is a class template that embodies a pointer that can be shared among different users such that when the last reference to the shared pointer is destroyed, the pointed to object is also destroyed. In effect, it is a sort of reference counted pointer. The upshot of this is that you can allocate memory with new, assigning the result to a shared_ptr, and then never have to worry about calling delete.

Here’s an example:

#include <iostream>
#include <memory>

using namespace std;

class C {
public:
    C() {
        cout << "Constructor: C" << endl;
    }
    ~C() {
        cout << "Destructor : C" << endl;
    }
};

class B {
public:
    B() {
        cout << "Constructor: B" << endl;
    }
    ~B() {
        cout << "Destructor : B" << endl;
    }
};

class A {
public:
    shared_ptr<B> pb;
    C *pc;
    A() {
        pb = shared_ptr<B>(new B);
        pc = new C;
    }
};

int main (int argc, char * argv[]) {
    A a;
}

This example compiles under GNU g++, but I’ve not tested it with any other compilers, some of which don’t have as good support for C++0x yet. You’ll need to use the –std=c++0x or –std=gnu++0x compiler options.
g++ --std=c++0x -o shared_ptr shared_ptr.cpp

If you compiler supports shared_ptr, try running this example. On my system it produces the following output:

eris@luthien:/vol0/eris/dev/study/c++/shared_ptr $ g++ --std=c++0x -o shared_ptr shared_ptr.cpp  && ./shared_ptr
Constructor: B
Constructor: C
Destructor : B

Class A has two members, a shared_ptr to class B and a regular pointer to class C. Both are allocated with new in A‘s constructor, but neither of them is ever explicitly deleted. Indeed, A has no destructor at all. But the messages printed by the constructors and destructors of B and C let us see that the B object – held through a shared_ptr – does get it’s destructor called when the program terminates, while the C – held through a regular pointer – does not. C‘s memory has leaked through the programmer “forgetting” to define a destructor for A, but the shared_ptr to B takes care of it’s deletion for us.

In other words, a shared_ptr saves us from having to write a destructor, and helps to prevent our feet from being shot.

Very nice!

The Very Basics
The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) by Joel Spolsky. The article is what it claims, and is a decent introduction to just what Unicode and character sets are.

Multi-byte-chars and Unicode on Windows
The first article I came across was also my introduction to the Filpcode Archive. Advanced String Techniques in C++ by Fredrik Andersson describes techniques for dealing with multi-byte characters and Unicode on Windows. It seems a bit complex compared to what I’m seeing on Linux, but this is an old article, so hopefully things have improved over the years.

Unicode and Linux
One older but useful article I’ve found is A Quick Primer On Unicode and Software Internationalization Under Linux and UNIX by Ed Trager. There’s a little technical information at the top, but mostly this article talks about the practicalities of using Unicode in Linux: the software you need and settings you might have to adjust.

The Locale in C
Over at IBM Developer works, I found an article titled Linux Unicode programming by Thomas Burger. This covers the basics of detecting and setting locale information in C in a Linux environment. Again, this is an older article, and I probably ought to have learned this information before now, but in the past I was programming system tools that generally had little, if any, user interface, so localization was never an issue. Now it is.

GCC beats VC++ ?
A lot of what I’ve been seeing indicates that working with UTF-8 – and in particular writing it to a file – on Windows requires you to explicitly convert your strings using WideCharToMultiByte() or set up some form of automatic conversion that hooks into the C++ streams library. For example, see Writing UTF-8 files in C++ by Marius Bancila. This is information I’m going to keep in mind, but my testing with GCC 4.5 on Windows and Linux makes me really appreciate that compiler. The first “naïve” example that Mr. Bancila provides as an example of fstream failing to write UTF-8 actually works just fine for me. On both Windows and Linux it writes a UTF-8 encoded file with no special effort on my part.

I’m still absorbing everything, but the more I read about this the more it seems that as long as I stick with GCC then I essentially get UTF-8 support for free.

The repository is linked in menu of the blog to the left as “My code repository”.

• The OpenGL Superbible, 5th ed.
• OpenGL Shading Language, 3rd ed.
• Game Engine Architecture
• Best of Game Programming Gems
• Mathematics for 3d Game Programming and Computer Graphics

And on top of that, this morning I found the Flipcode Archives while searching for information about dealing with Unicode.

Of course, once I’ve worked my way through all of these I’ll really have only scratched the surface, right?

Well, it’s going to be a long haul, but I’m still having a blast with it. With so much to learn I’ve been taking the approach of reading in one book until I reach a point where I feel like I can’t usefully go any further. For example, I read in Game Engine Architecture through chapter 6 and then felt like I really couldn’t do anything else until I could put what I’d learned into a real context, but for that I needed to have some actual graphics code to build on. So it was then that I turned to the OpenGL Superbible. I’ve mostly read through it’s chapter 6 now, and in order to move forward in it I feel like I need a rudimentary engine to experiment with. Synergy time!

So now I’ve set myself the task of creating my first crude object, scene, and resource managers. For a little inspiration I’ve turned to the source code of the HPL1 Engine from Frictional Games. You can download it here. Looking at the HPL1 startup code is what got me thinking about Unicode.

So far I really haven’t made much progress. I wrote a log file class the other night, and I’ve got a config file class for dealing with Windows style .ini files that I wrote a while back, but my job and the long drive to and from work keep me busy, so I don’t have a lot of free time to work on things.

I’ll post code when I have more of it, but in the meantime enjoy the reading list. All of the books I linked to are really excellent, and some of them are often described as the definitive tomes on their topics, which is what led me to them in the first place.