Marc O’Morain

eflow.ie is the worst website that I have used in a long time. It is broken in Firefox, IE7, (gives errors when you click on buttons, etc) and apparently Chrome is “unsupported”. The site feels like it should have a “BEST VIEWED IN 800×600 RESOLUTION KTHX BAI” scrolling marquee along the bottom.

I assume who ever wrote it was well paid for the job.

http://www.dyson-game.com/

This game is awesome.

Hotplugging support for input devices actually works now, so you can plug in mice and tablets and use them without having to reboot.

Awesome, it’s like all the power of Windows 2000.

What if the Mega Man 3 Title Theme had lyrics?

http://www.facebook.com/common/error.html

:)

One of my favourite games from the N64 has a new sequel in the works, due out this year.

This should have taken about an hour to copy.

I just noticed some really lazy web programming. Go to CarZone.ie and select a car type. I picked Porsche, and hit ‘find’.

But the website can’t do a search based just on car type. Here is the error dialogue that I got:

This is a bit annoying, since I don’t know what type of Porsche I want, I just want to look at Porsches. So I followed the site’s advice and went to the advanced search page. I selected Porsche, and hit find.

But when doing an advanced search, just giving the type of car was enough. Here is the list of Porsches:

Why can’t they just do that on the main page?

I added a new page for my new program, screenshoot.exe. Read about it here.

I came across this article on reddit. It contains the following sentence, that left me awestruck:

“Many industries are barreling toward paradigm shifts that will require the high-level programming and development skills needed to create and maintain industrial-strength applications for multi-core processing, large-scale Internet computing and Software as a Service (SaaS), as well as rich clients for desktop, Web and mobile platforms.”

This is a CAPTCHA resistance test. Fun.

I read about the following way of implementing virtual interfaces in Exceptional C++ Style, but I only really realised the need for it this evening.

Suppose I have a class like this:

class Object
{
  public:
    virtual void translate (Vector d) = 0;
};

Other classes will inherit from Object, and they will override translate() as necesssary.

class Ball : public Object
{
  private:
    Vector m_position;
  public:
    virtual void translate (Vector d)
    {
        m_position += d;
    }
};

Now, suppose later on I decide that I want to keep track of the last time an Object was moved. I might add a variable to store the time of the last movement. I can then set this variable to be the current time in Object::translate().

class Object
{
  private:
    float m_timeOfLastMove;
  public:
    virtual void translate (Vector d)
    {
        m_timeOfLastMove = getCurrentTimeFromSomewhere();
    }
};

Now, because translate() was abstract, every other class that I have derived from Object has implemented its own custom implementation of translate(). I now need to go through all my code, and add a call to Object::translate() in each implementation of translate().

class Ball : public Object
{
  private:
    Vector m_position;
  public:
    virtual void translate (Vector d)
    {
        Object::translate(d);
        m_position += d;
    }
};

This involes a lot of copying and pasting of code, and I end up with calls to Object::translate(d) all over my code. If I forget to add one of these, the compiler will not complain. If I derive a new class from Object later on, and forget to add this call to the base implementation, I have created a new bug also. The bug will likely not lead to a crash immediately, as I am not doing anything particularily dangerous by not calling the base implementation of translate() in this case. If the bug does not lead to a crash, I might not know that the bug exists for some time.

If I had seperated the implementation of translate() from the public interface right from the start, the code would have been more flexible.

class Object
{
  private:
    virtual void translateImplementation (Vector d) = 0;

  public:
    void translate (Vector d)
    {
        translateImplemenentation(d);
    }
};

The Object class now has two contracts: Any Object can be translated by calling Object::translate(), and any class that derives from Object must implement translateImplementation(). I am free to change one of these without affecting the other. For example, I could rename the translate() function to move(), and I would not have to change any class the derives from Object.

Suppose I wanted to allow for rotation in the movement of Objects. I could change translateImplementation(Vector d) to transformImplementation(Matrix m).

class Object
{
  private:
    virtual void transformImplementation (Matrix m) = 0;

  public:
    void translate (Vector d)
    {
        Matrix m;
        m.translation = d;
        transformImplementation(m);
    }

    void transform (Matrix m)
    {
        transformImplementation(m);
    }

};

All classes that derive from Object would have to change their implementation of translateImplementation(), but all code that calls Object::translate() would not have to be to changed. I can keep the existing translate() function, but also add a transform() function.

The fact that I have made translateImplementation() private is very important. If any other code wants to translate an instance of Object, it must call Object::translate(). It is illegal for any code to call translateImplementation() directly.

Now if I want to go back and modify translate(), it is much easier for me. I may want to add some profiling or logging to all calls to translate(), or I might want to impose some pre-conditions or post-conditions. I can be confident that any additions to the translate() function will not be bypassed by some other class which derived from Object.

I have been using this little function in the game I am writing:

template <typename Target, typename Source>
inline Target checked_cast (Source* source)
{
    // In debug, make sure that the cast is valid, using RTTI.
    assert(dynamic_cast<Target>(source));
    return static_cast<Target>(source);
}

In release, it compiles away to a static_cast, whereas in debug it will assert if the cast is invalid.

Can’t see in? This is a link.

CIMG1430.JPG

Originally uploaded by marc_omorain.

My photos from Yosemite are online.

Dear Visual Studio 2005,

Thanks for taking all of the resources. Waiting for you to update intellisense is the best part of my day.

It seems like a lot of people have the same problem.

KTHANKSBYE.