Limegarden.net Personal site of Wouter Lindenhof

Testing wordpress scheduling

One of the things I like of wordpress is the fact that I can schedule my posts. That is until it breaks.

I had a post scheduled at 1200 today but when I checked it at home I noticed that it hadn't updated yet. It even said that it had missed its schedule. Calling the cron job a few more times didn't do anything so this is just a quick post to check if it does work now.

Update @ 2012-02-02 00:06: It seems to be working just fine

Happy new year!

Goodbye 2011 and welcome 2012. I wish everybody a happy new year.

New job!

When I first created my site, I once joked that it is, besides a platform for me to talk about various subjects, it would also be a professional business card in which I present myself to any prospecting employers. Well, the joke is on me, since I was actually contacted through the "contact me" form and was offered a job. I went in on the job offer and within two meetings I had signed the employment agreement and I have a really good feeling about it.

The downside is that I had to talk to my current boss about me leaving, which I did the next day. I have never done something like this before and the only time I was "let go" was due to the fact there was no more work for me. But instead of getting angry or sad I  was happy with the news. The HR (Human Resources) person who brought me the bad news had trouble understanding this (I was smiling) and I had to explain that I didn't feel OK with only showing up and then do nothing. Maybe it is my sense of pride, but I rather have no job than not doing my job.

So that day I asked my boss if he and I could have a few private words and explained that I would be leaving. I had talked it over with my dad how to do such things and what should be done in which way, but my boss was a true sportsman and except a request if I could stay one month longer to give him more time (which I declined) there were no problems. The reason why I tell this is because there are plenty of stories (often American) where someone is escorted from the premises without even giving them time to grab their jacket. Those are horror stories and a clear case of a lack of trust and proper behaviour, but this was the exact opposite.

So that is the news. I have a new job starting the first of May (well second actually since the first is a Sunday) and except the bit of overtime at my old job to ensure that me leaving there has a minimum impact (technical documentation and finishing a few projects) it seems there are no problems professional and personal. Now all I need to do is find a new home and wait until it is time.

Plug-in system in C# and C++

(if you are reading this article through a feed, you might want to switch to the website because of code highlighting)

In this post I will explain a easy to use plug-in system for both C# and C++. Yes, they are different languages...
If you want to skip my babbeling just scroll down and you can find the source code.

Plug-ins are rather cool as you can write one plug-in and use it for everything. They can add (or replace) functionality without having to modify the application itself. Of course, there is a small downside and that is that plug-ins can be quite a bit slower as they need to be integrated in your application at runtime instead of compile time.

A plug-in framework is in my opinion something that is easy. Instead of calling a function from the executing module/assembly, you call it from another module/assembly. Lets start with a simple logger, which has one function namely Log that has string as content.

class LogFile
{
    public:
    // inits a log with the given log file
    LogFile(const char* const filename);
    // Logs text
    void Log(const char* const logText);
};

But then someone says that he has trouble reading the plain log file and wants something that is more graphically appealing and suggests HTML and you think, oh, fine, why not. But how are you going to solve it? And while you are thinking about the solutions the big boss comes to your desk and says he wants to import the log in a reporting facility which only accepts csv. And then a third persons comes and tells you how cool XML is and you also add it to the list. Now you could write something like:

// Without the open/closed principle
enum LogFiletype
{
    LOG_FILETYPE_TXT,
    LOG_FILETYPE_HTML,
    LOG_FILETYPE_CSV,
    LOG_FILETYPE_XML,
};

class LogFile
{
    public:
    // inits a log with the given log file
    LogFile(const char* const filename, LogFiletype filetype);
    // Logs text
    void Log(const char* const logText);
};

Now before we start adding more formats, I would like to point out that this is clearly a case where the Open/closed principle should be applied. Simply put it says that anything should be closed for modification but open for extension. In the above example, we are constantly extending our existing LogFile with new functionality. If we would apply the open en closed principle we would get something like:

// With the open/closed principle
class ILogFile
{
    public:
    virtual ~ILogFile() { }
    // Logs text
    virtual void Log(const char* const logText) = 0;
};

class LogFileTXT : public ILogFile
{
    public:
    void Log(const char* const logText);
};

class LogFileHTML : public ILogFile
{
    public:
    void Log(const char* const logText);
};

class LogFileCSV : public ILogFile
{
    public:
    void Log(const char* const logText);
};

class LogFileXML : public ILogFile
{
    public:
    void Log(const char* const logText);
};

Now if you need to add an extra filetype you simply extend ILogFile and you are done. The downside of the above method however is that if this system is in a single library (*.lib) you will have a lot of dead code. Also as every programmer knows, a small codebase is easier to maintain than a large codebase. We can solve this by using plug-ins. Each logger is put in a separate dll and only the Dlls required are used.
The reason why I used to above example is not because I want to point out that small codebases are easier to maintain than large codebases, but because the open/closed principle is a very important aspect for my plug-in system. The projects (both attached at the bottom) work because of it.

Writing a plug-in framework is often explained as difficult while in fact, once you understand the basic principles, it can be rather easy. As a programmer we must work hard to be lazy. The first one is that all plug-ins are derived from IPlugin which is defined as followed:

class IPlugin
{
    public:
    virtual ~IPlugin() = 0;
    virtual std::string GetName() = 0;
};

The above is in one word useless on its own, except a name (which is only there to identify the plugin) it is basically an empty class. However lets add two new functionalities to it.

class IPluginInput : public IPlugin
{
    public:
    virtual void DoInput() = 0;
};

class IPluginOutput : public IPlugin
{
    public:
    virtual void DoOutput() = 0;
};

And we have two types of plugins we know that if a plug-in is derived from one or the other it has a certain function. We know that one can do input and the other can do output. In C# we could have the following:

List<IPlugin> allPlugins; // Contains all the plugins

List<IPluginLogger> loggers = new List<IPluginLogger>();
foreach(IPlugin plugin in allPlugins)
{
    if(plugin is IPluginLogger)
    {
        loggers.Add(plugin);
    }
}

foreach(IPluginLogger logger in loggers)
{
    logger.Log("Hello world!"); // Logging in HTML, TXT, CSV, XML
}

So if you are writing a game (or software) and you want to add a new type of AI (or business rule) you simply derive from IPluginRule, which is a defined interface for that specific behavior, and you can quickly add new rules. So once you have your basic framework setup (we get to that in a minute) writing plug-ins becomes really easy. Of course if you have something as complex as graphics engine or adding new features to a form, it becomes quite a bit harder.

The plug-in framework is where the majority of the problems come from. Luckily you only have to do this code once. The basic steps are as followed:

1. Select a folder that contains plugins
2. Load all modules/assemblies.
3. Get an instance of all plug-ins

I'm going to skip step 1 and step 2 and only discuss step 3. If there are any questions regarding step one or two after you have reviewed the source code just comment and I will try to answer as quickly as possible.

Step three involves getting an instance of all the plug-ins. You might not want an instance of the plug-in but rather a factory, but the bottom line is that in the end we somehow need to have an instance of the plug-in. In C# we only have to use reflection.

/* modified snippet from the source code */

// Find all objects that implement IPlugin
pluginTypes = pluginAssembly.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(IPlugin))).ToList();

foreach (Type pluginType in pluginTypes)
{
    // Getting the constructor
    System.Reflection.ConstructorInfo pluginConstructor = pluginType.GetConstructor(new Type[] { });

    // Invoking the constructor to get an instance of the object.
    IPlugin plugin = pluginConstructor.Invoke(new Object[] { }) as IPlugin;
}

C++ doesn't have reflection (RTTI is not really the same) so there it is a bit different. Instead of letting the framework find all plug-ins in a certain module (dll), we export only one function in the dll. This function has as sole task to instantiate a plugin and register it with the framework.

// dllmain.cpp
extern "C" __declspec(dllexport) void RegisterPlugins(PluginCore* core)
{
    core->RegisterPlugin(new ExamplePlugin(core));
    core->RegisterPlugin(new ExampleInputPlugin(core));
    core->RegisterPlugin(new ExampleOutputPlugin(core));
    IPlugin plugin = static_cast<IPlugin*>(static_cast<IPluginInput*>(new ExampleCombinedPlugin(core)))
    core->RegisterPlugin(plugin);
}

// Load each dll and find the plugin factory
for(size_t i = 0; i < files.size(); ++i)
{
    HMODULE dll = LoadLibrary(files[i].c_str() );
    RegisterPluginsFunc registerPluginsTo = (RegisterPluginsFunc)GetProcAddress(dll, "RegisterPlugins");
    // Create all plugins and register them to this core
    registerPluginsTo(this);
    m_Modules.push_back(dll);
}

Download the example files for both C# and C++

Ubisoft DRM

Recently I bought "Settlers 7" and even though I enjoy the game, it is the first game that I want to remove after only 21 minutes of in game time. The reason for this is the DRM (Digital Right Management).

Now I'm not one of those guys who says that DRM is bad as piracy is a problem and it should be dealt with. I don't think that DRM would improve sales either as people who pirate a game either have no intention of buying or are unable to buy due to some reason (territory, credit card instead of debit card required, et cetera). The only reason why I think DRM works is because installing a crack might be more hassle.

The DRM in Settlers requires you to be always connected to the internet and if for some reason this is not the case, it will stop the time in your game until you are connected. My PC is on the third floor of our house. The router is on the first floor of the house. I have boosted the signal to 150% but because we have a lot of wireless networks in our neighborhood which sometimes interferes with our wireless network.

The result: The game reports I have only played 21 minutes while the game is already running for 50 minutes.

Now I admit that one of the reasons of buying the game was that I wanted to see how the DRM would work and how I as user of the game would experience it. As an user I didn't mind it the first time I could understand it, the times after that I started to get annoyed. As a gamer you want to move your game forward, not wait until someone says "Ok, your game is legal". This wouldn't be an problem if this has once (or maybe twice or thrice) every hour but when the game starts and stops every 5 minutes it breaks your flow. Once every hour would be like a commercial, giving you a natural pausing moment, once every five minutes is like you require the toilet every five minutes because your diner was spoiled and rotten. The next time you eat diner you sure as hell will avoid eating something rotten.

And this is the problem I think Ubisoft will have to solve. The DRM as it is now or as how I experienced can be rotten in certain situations and people in that situation will avoid your games in the future. What is worse, they will talk about their experience and even though the problem is on their side, Ubisoft will lose a potential customer. Those who had good experience will even though they have had different experience also try to avoid it as they might be in that same situation someday.

On top of that, requiring a constant internet connection is a bad idea because of:

• Privacy, Ubisoft knows when you play, what you play and how you play.
• EULA, they say they can change it anytime they want (not entirely true, but they say it)
• What if I have no internet connection?

As you can see there are plenty of reasons to avoid this kind of DRM. I'm interested to see if this DRM will be accepted and if not long how long it will last.

No update for Story Editor, next week a major new feature

This week there is no update for Story Editor, but next week I will have implemented a major feature which makes that version of Story Editor a complete version.

The new feature can best be compared to a database in which you can create your own content types like persons, items and what else you can think of. Don’t know the age of a certain person? Just open a quick screen in which you can look up your character!

But that being said it will take at least one more week to fully implement it so that is useable. After that I might add some more complex features, although I have to take care in not adding too much features.

Then I have to make a design decisions as I’m not yet finished. For one I could start working on a publishing site on which users can register and to which Story Editor can save and load stories. Imagine writing your story and then publishing it with a single click!

Or I could add relationships in the database. This I think is the biggest challenge, as I’m starting to write a database.

The last thing that is on my list is change the GUI so that it no longer depends on propriety software. That would mean I could put the source code online so that others have access to it as well and might learn from it.

Looking at things that I want to do and the final deadline (I stop actively working on this project when it is 2011) I might make it or I might just miss it.

Anyway here are some screenshots of what I mean with content types:

You can create your own types

Fixed bug in story editor

As I had mentioned yesterday at late night, there was a small but highly annoying bug in the Story Editor, which I have now fixed.

You can download a new version here: Story Editor V0.0.0.2

Next week I will add reordering in it. If anyone comes across a bug, feel free to reply on this post.