In this article I would like to look at some Haskell features I really liked. As I know that most of our readers are not Haskell experts I have decided to keep it quite general and simple.

Function transformations

Function composition

Function composition is a technique of combining two functions into one function.

f1 . f2

This says that function f1 should be applied to the result of applying f2 to its first parameter. So, above code could be rewritten to:

(.) f g = h
where h x = f (g x)

The type of h can be deduced like this:

f :: a -> b
g :: b -> c
– Thus:
h :: a -> c

Function application

Function application is not exactly a very exciting feature, but it is helpful as it helps you to get rid of annoying extra parantheses.

f1 $ f2

This says that function f1 should be applied to the result of function f2. Now you are probably what the difference is with f1 f2.

When you simply type f1 f2, f2 is considered as a parameter for f1 and all of the parameters of f2 will be considered as n-ary parameters of f1. When you type f1 $ f2 you first apply f2 to all the following parameters, and f1 is then applied to the result of f2.

So, for example:

sum x y z = x + y + z

successor x = x + 1 — A better alternative is discussed in the next section!

test1 = successor sum 1 2 3 — Will not work. After all, you cannot take the successor of a function.
test2 = successor $ sum 1 2 3

Partial parameterisation

Partial parameterisation is a technique to partially satisfy a function. This technique can be used to create new specialized functions.

For example, if we would want to declare a function that gives us the successor of the given integer, we could simply write:

successor = (+) 1

or

successor = (+1)

This would make the following example valid:

> successor 41
42
> successor $ successor 41
44

successor is of course an incredibly easy example of partial parameterisation, and it might give you the impression that its just a gimmick. However, in combination with function application and function composition its an incredibly useful mechanism.

A slightly more complex example, is a function that gives us the successors of all elements in the given list.

successors = map (+1)

Operators

Another cool feature of Haskell is the ability to define your own operators. As this is actually rather simple I am not going to spend much attention to it.

Lets say we would want to express addition and substraction through smilies. It could be done like this:

x ^-^ y = x + y
x -.- y = x – y

Or with partial parameterisation in our mind:

(^-^) = (+)
(-.-) = (-)

Which would make the following valid:

> 1 ^-^ 2
3
> 3 -.- 1
2

In the latter definition you can see how operators can also be used as functions: you simply put parantheses around them. And the fun thing is that a similar trick can be applied to functions with two parameters:

min :: Int -> Int -> Int
min = (-)

> 3 `min` 1
2

In order to use a function as a operator you have to put backquotes around it.

Again, this might seem like a gimmick, but it can be pretty useful in the field of “symbolic evaluation”. But more on that another time.

Lazy evaluation

Lazy evaluation is one of the most powerful features, if not the most powerful feature, of Haskell. Lazy evaluation is the technique of delaying a computation until the result is required. This means that the data that is required for a computation is retrieved at the moment that the computation is actually executed. This makes it possible, for example, to work with lists of infinite length without actually computing the complete list. As lazy evaluation is beyond the scope of this article I would like to refer interested readers to Wikipedia, which has a nice article on the matter.

And with that I would like to conclude my first article about Haskell. I hope you enjoyed reading it. And as always: if you have questions or comments feel free to post them.

Thus, there are very few updates, but here’s futurePosts.peek();

1. The first update I really want to do is work on the Language … thingie. We still don’t have a good name for it. Seeing how it can generate words and such it might be a fun tool to play with. Maybe we can generate a word and use that as a name.
2. The second one is about the electronic drumkit. I want to drum so badly but I can’t fit in in my day, let alone fit enough time to finish the thing, but it shall be done! Sometime in the hopefully near future.
3. There’s no three. But post something you want to read/talk about.

Anyhow, I know we still have some regular visitors (mostly thanks to Michael I think, his articles are almost always at the top of viewed pages in Google Analytics), and don’t leave. Sign up for the rss/atom feed so you don’t have to check each time but get notified. That is if you’re using a decent rss/atom feed reader, I like Google’s.

If anyone has any ideas for the Language thingie do post them by the way! Implementations for ideas, ideas only (don’t feel limited by implementation difficulties), anything really. A little feedback is always nice to get.

Some definitions for the following paragraphs:

Text: any text. Can be a complete book, a word, a sentence, etc.

LR<Languages>: Language Recognizer for the languages.

Possible applications of the LR

Advanced Texthelper

Features

Can correct words without a dictionary: recognizes when something probably isn’t a word.

A word of length X has an average score of AVG. If there is a word with length X and its score is lower with significance S, then the word probably isn’t a word in the current language. I don’t know how to determine significance S.

Can correct sentences, since it also recognizes sentence structures.

Basically the same as the word recognition, but for sentences.

Can auto-complete sentences (and parts thereof).

Since the LR keeps tracks of how many times a word follows another word, it should be able to predict what word you are going to type, which could speed up writing a text. As you read, a lot of shoulda coulda woulda, but maybe we are clever enough to pull this off.

Language Recognizer

Features

Can tell if text A is more English than text B

If text A scores higher on LR<English> than B, A is more likely to be english than B.

Test results indicate very few false positives with a simple implementation.

Can help for auto-recognizing if something is human readable text.

If a text gets a higher score than previous texts, the text is more likely to be human readable text, which is useful for the “recovery” of encrypted text.

Language

I’ve been experimenting with some fun stuff lately, it involves language, programming, password-dictionaries, spell checkers, and more .

1. Get a file with a lot of words (i.e. a spell checker dictionary).
2. Count the occurrences of N-letter-groups in those words. (example with N = 3: “hello”, hel++, ell++, llo++)
3. Find high-scoring letter-groups which overlap (ie. “hel” + “ell” = “hell”) to form a word. (Obviously, repeat this to form bigger words)

Using an English dictionary, this gives output such as: “anteringlogratio”, “callinesthesional” and “prestionistering”. Altough those words are absolutely not English words (as far as I know), they look pretty English. Cool huh?

It can obviously also create ‘fake words’ in other languages, by using other dictionaries. For example, using a Dutch dictionary: “verderendelijker”, “heiderdelijkeren” and “eerderingelijkerigen”. (I’m Dutch, and I can tell you those words are easy to read and pronounce, altough they mean nothing to me)

I can hear you thinking: “Nice, but why’d you ever need to create ‘fake words’ ?”.
Well, for example, we could expand a password-dictionary by generating new passwords from the passwords already in there. This gives new passwords wich are likely to be passwords, instead of the 99% of garbage from a simple brute-forcer.

Also, if we can create words that seem to belong to some language, we can probably also recognize if something could be a real word.

We could create a program wich can tell random sequences of letters and real words apart by giving the words an ‘Englishness-score’, the more it uses high-scoring letter-groups, the higher the score. This might come in handy while brute-forcing a password for some text file. The program could detect if it succesfully decrypted the file, or just got some garbage-output. Or we could create a smart spell checker wich can check and correct words even when they’re not in the dictionary. If ‘hello’ has a much higher score than ‘helllo’, the user probably wanted to type ‘hello’. Or a language-recognizer, if all the words have a higher ‘Dutchness-score’ than ‘Englishness-score’, it’s probably not an English text.

When we take this a level higher, not using words and letter-groups, but sentences and word-groups, the awesomeness grows exponentially. A spell checker could simply correct “Ive is fun” to “Ice is fun”, but “Ive been running” to “I’ve been running”. An internet spider could tell real text apart from those random-keywords-pages. Lots of possibilities.

Anyway, I’ll try to code some of this stuff to see how well it all works, stay tuned.

Lets start with a reply to the original article. Some while after the article was published on .simplicity Valentin Anastase from the non-profit organization Freezing Moon replied. He provided a link to two sites, including Freezing Moon’s, dedicated to free gaming. Freezing Moon comes close to the idea that I sketched in the previous article, but it is not completely the same. Opposed to the Free Gaming Alliance, Freezing Moon actually develops games themselves. While I think that we should first deal with other issues concerning free gaming, I am happy to see an initiative like Freezing Moon and I encourage people to check it out.

Another interesting development can be found at OpenGameArt.org. OpenGameArt.org is a website that hosts “free, legal art for open source game projects”. It started small, but the amount of art has been growing fast. And the art that is being hosted on OpenGameArt.org is certainly not bad; it looks very good. If you are looking for art for your Free Open Source Game or want to support free game art (OpenGameArt.org accepts donations), then definitely check OpenGameArt.org.

So, there are initiatives focused on Free Open Source Gaming, but what about me? Through Sirrf I am trying to improve the Free Open Source Gaming ecosystem. I am wondering if I can have an impact on it in other ways, though.

Sorry for the long time no update, hope you are still watching.

Some small updates after the break.

Medievil

The first game I decided to play on the emulator. It was decent fun, but the best part was really in the story. It’s not the depth, but it’s the humor. The green gargoyles keep mocking you in really funny ways and the text is just top notch. Medievil’s story telling is for games what Shakespeare’s was for drama, a thing to strive for.You play Sir Daniel Fortesque who is a hero from long long ago. He battled his way to the evil sorcerer Zarok’s castle and with his dying breath he killed Zarok. At least, that what’s the books say. What really happened? Get the game, I don’t want to spoil that for you. But keep in mind that this is a really funny game. Anyhow, several decades or so later you wake up from the dead because Zarok is at it again and it is up to you to stop the evil sorcerer.

The sound was good! Almost every level has it’s own theme and they all fit, plus the voice acting! I like it a lot. In the Hall Of Heroes, a bonus-shopping level, each hero has it’s own accent and funny lines. Good stuff.

The gameplay was decent. Replay value is none, which makes it a short game. My first and only run through the game took me 5 hours. Some annoying things are the jumps: Fortesque can’t jump that good and you fall to your death way too often. It’s frustrating, it adds unnecessary repetition to the game. The fighting is more button bashing (or when you have a turbo-button like me, button holding) than strategicly doing stuff. You run, you charge your special attack, you kill the monsters. None of the monsters are a real threat which in the end makes this play more like a platformer and since Sir Dan sucks at jumping and steering him while running isn’t with the accuracy of a modern day FPS the game doesn’t score high on gameplay. The game has some wicked weapons and even a shield system which is easy to master and use, but you’ll never find yourself using it because you’re invincible as long as you keep hitting attack. It’s a shame really, the fighting could have made this game a lot more special and fun.

In the end:

+Good story!
+Good sound!
+Lots of humor

-Plays like a platformer, and not a very fun one.
-No replay value, short playthrough, combined making it a short game.

Medievil’s good sides make up for the suckier parts. Medievil is definitely worth a look: 6 points.

Stay tuned for when I finish my next game!

The first project that you can find on .simplicity Code is the .simplicity Java Sigslot Event System. This is, as the name already says, an implementation of a sigslot event system in Java. A sigslot event system allows the programmer to connect components within a system without that those components know with who they are actually connected. Furthermore this system can also be used as a broadcasting system for sending information to multiple subscribed components. Sigslot event systems can be applied in various different cases, such as component-based entity systems and graphical user interfaces.

But lets look at some example code using the .simplicity Java SigSlot Event System:

// Import classes
import java.applet.Applet;

import java.awt.Graphics;
import java.awt.event.*;

import net.dotsimplicity.events.awt.AWTEventsContainer;

// EventApplet class
public class EventApplet extends Applet
{
    // Public methods
    // Initialize the applet.
    public void init()
    {
       // Create an AWT EventsContainer.
       AWTEventsContainer container = new AWTEventsContainer("applet", this);

       // Add a mouse moved event.
       container.addMouseMotionListener();
       container.connectEventSlot("mouseMoved", this, "onMouseMoved");

       // Add a custom event.
       container.createEvent("print", String.class);
       container.connectEventSlot("print", this, "onPrint");
       container.emitEventSignal("print", "Hello, World!");
    }

    // Paint the applet.
    public void paint(Graphics g)
    {
       g.drawString("X: " + this.x + ", Y: " + this.y, 10, 15);
       g.drawString(this.message, 10, 30);
    }

    // Handle mouseMoved events.
    public void onMouseMoved(MouseEvent event)
    {
       this.x = event.getX();
       this.y = event.getY();
       this.repaint();
    }

    // Handle print events.
    public void onPrint(String string)
    {
       this.message = string;
    }

    // Private members
    private static final long serialVersionUID = 1;
    private int x, y;
    private String message;
}

// End of File

In the above example we have created an applet that uses our sigslot event system to handle mouseMoved events. Please note that we do not have to implement the MouseMotionListener interface; you are free to only implement those features that you need under whatever name you choose. That means that you no longer have to implement six empty methods if you want to use one feature of the WindowListener, for example.

Furthermore we also use our event system to transmit a signal with the message “Hello, World!”. In this particular appliance this is a rather useless operation, but it demonstrates in a simple way how we can use our system for broadcasting. Note that you can also use the relatively simpler EventsContainer for this appliance; this class provides all methods that the AWTEventsContainer provides except for the AWT specific methods.

Well, that is all for now. We hope that .simplicity Code will be of use to you.

I installed Ubuntu on my laptop a while ago, but didn’t use my laptop a lot because I had a computer that was about 30 times as fast (P3 Mobile vs. Core 2 Duo). But when I’m not at home, thus not at my computer, I only have my laptop! And since I’m far far away from home now for my study… I got to know Ubuntu a bit more.

I must say my first few Linux tryouts were.. bad. First try was Fedora Core 3 which was.. nasty. The 14 year old me didn’t know what packages to get and what not to get, let alone the proper size for a swap partition.

Years later I installed Ubuntu 8, first having tried some setups in a virtual environment. I liked it, and figured I could get used to the nice “Add/Remove…” option in Applications. But my music! The sound sucked. So I tried installing drivers for my Realtek’97, I think. Installed the driver (I guess), rebooted, tried to log in.. Which failed. I cursed Ubuntu for not letting me log in with a faulty sound driver and promptly reinstalled Windows.

So, now, Ubuntu 9, Jaunty Jackalope… I like! So much liked it on my laptop that I also installed it on my home PC (the fast one) and I liked it even more. It even basically auto-installed my videocard driver (asked me what version I wanted)! Windows doesn’t do that, hehe. Windows 7 does I think, but still, +1 for Ubuntu.

There were 2 obstacles:

• Flash on x64
• Surround Sound

Flash was a bit of googling to do. I heard people on Windows x64 had the same problems so… Nothing to mourn about. Just a bit weird that the Adobe site didn’t offer a lot of help for x64 (not on the download page anyway). In the end I found the alpha x64 version and it works like a charm… nah not really. Firefox crashes when I play any game on Kongregate. But it’s Alpha and it’ll be fine when the first RC comes around.

Surround sound took me some googling but I figured it out. You need to add the “Surround” and some other sliders to the Volume Control and then you’re done! Man that was easy. Ubuntu took away the driver installing troubles: video and sound. Pretty neat. Now my computer even uses the subwoofer with Youtube vids, something I can’t get to work in Windows. So again +1.

Enough Ubuntu praise for today. Now go get your copy.

• Script-side GameStates
  It is now truely possible to derive from the GameState class (through CGameState) in scripts. A bug in previous versions prevented this, but this bug has now been fixed.
• Script-side Components
  EntityComponent can be derived from script-side (through CEntityComponent), classes in script can now create components and register them with entities from script or engine side.
• Script-side Events
  The event system is now integrated into the script engine. Script-side classes can derive from IHasSlots and can register, connect and disconnect from slot events.
• Important Bug Fixes:
  • Construction of entity components with parent is now relatively safe. If you are not sure whether your component has a parent, check it after construction. If the component has no parent, destroy it as quickly as possible
  • AssetProcessors on windows were never loading assets unless the files were all lowercase, restrictions were irrlicht related but solved.
  • Minor bug fixes with script side things, Scolor fixes, asset groups on entities and much much more.

Useful links
SourceForge.net page – http://sourceforge.net/projects/sirrf
Downloads – http://sourceforge.net/projects/sirrf/files/ | http://www.ohloh.net/p/sirrf/download?package=Sirrf
Documentation – API | Tutorials

• Asset Management
  The biggest new feature is asset management. Assets are managed by the AssetManager class. This manager manages so-called asset groups, which represent a collection of assets (meshes, textures, etc). These assets are retrieved from a directory with the appropriate directory structure. In turn the found assets are processed by asset processors. And at the end of the road, the user can use these assets without having to deal with paths. Furthermore asset management makes it possible to reload all assets in realtime, with direct results on the current scene. Reloading assets is as simple as one function call.
• XML-based Entity files
  It is now possible to load data concerning entities and their components from XML-files. This means that you can now define a scene through XML-files.
• Local Event System
  As of version 0.2.0 a HasEvents class, which provides the base for a local event system, is available. The availability of local event systems makes the entire framework more performant. Currently the HasEvents class is used by entities and asset groups.
• Microsoft Visual C++ 2008 support
  Version 0.2.0 is the first release that officialy supports Microsoft Visual C++ 2008. This should make it easier to set up Sirrf-based projects accros multiple platforms.

See the change log for more information regarding the changes in Sirrf version 0.2.0.

This is not the end of Sirrf’s development, though. Sirrf’s development will continue and Sirrf will undoubtely become even better in the future. And you, as a Sirrf user, as a member of the Irrlicht community, can help us improve the framework. This can be done by contributing code to the project, but also by testing the framework. Either way, we hope that Sirrf will be of use.

Useful links
SourceForge.net page – http://sourceforge.net/projects/sirrf
Downloads – http://sourceforge.net/projects/sirrf/files/ | http://www.ohloh.net/p/sirrf/download?package=Sirrf