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.

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.

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.

• 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

All in all, I think Ohloh is an interesting service. Certainly something worth a visit. And if you decide to visit Ohloh, don’t forget to visit my user page too.

Besides that we’ve (Maurice and I again) a arbitrary length number class, dubbed superint. Original huh? It’s efficient with the bytes and cycles, uses x86 ASM for all the instructions and gives the right answers. Currently support addition, substraction, multiplication, division and modulus. We’re making a version 2 with what we’ve learned so far which will have some more features. Stay tuned for the source, zlibbed we thinks.

Sorry for the long time no post! I promised an abstraction tutorial. It isn’t coming, still can’t find examples. The articles I write just spin around my mind a bit, evolve in there and then come out with some reviews. And besides half of my review crew is currently unavailable (Maurice is on a vacation), they aren’t spinning in my mind.

“But Nick,”, I hear you say, “what ARE you doing, programming-wise?”

Glad you asked! However, it’s very, very little. I’m busy with Pixlings. I realized that this is a much bigger project than I anticipated. There are so many parts doing different things that need to work flawlessly together. In contrast, all of my programs until now had one objective and were no longer then a few hundred lines perhaps. I wrote tons of those, but bigger projects are really a lot harder. Therefore, I’m now focusing on game-development in general, development on Pixlings has seized until I am a better game programmer. Can’t tell a couch potato to run the marathon eh.

Besides programming there are many, many parties. This weekend wrecked me, slept very little and when I did it was at unfortunate times. I leave it up you to figure that one out for yourself.