Mittwoch, 27. Januar 2010

Multitouch Graph Solving Game - or - Math Can Be Fun!

Hello folks,

in long long ago 2009 I had that little project with a multitouch-table, which I think might be worth sharing. Actually it handles the problem making a so called graph planar.
Don't run... it's a math problem! But its fun!

The videos show best how it is played...

On the project blog you can find valueable information (in German, sorry) about the project, what tools were used and how the lightning was setup up.

You can actually download it (for free) from the Android Market if you have a supersized multitouch table to call your own:


Montag, 25. Januar 2010

Scala + GridGain (+ Eclipse + JUnit) = WIN

Recently I stumbled upon GridGain, which seems to be a highly interesing Grid-Framework written in Java. Due to the fact it is written in Java it is supposed to be working with Scala, my upcoming favorite JVM language (Sorry Java!).

Having watched the screencasts by Nikita Ivanov I was kind of forced to give a try! You should watch them to, they explain every single step to take when using GridGain with Java.

This is the specific setup I was using:
  • Eclipse: 3.5.1 build 20090920-1017
  • GridGain: 2.2.1
  • Scala: Scala Library version 2.8.0.r20638-b20100123020158
  • JUnit: 4.5.0.v20090824

To give you an idea of what GridGain (in Java) is like and how to make code run in the cloud with basically just one annotation:
public int superHeavyMethod(int x, double y){
   // ...
Oh yeah, we do like that =)

So as you now have watched the screencasts, I show you how to do the same in Scala. For this example, I chose to execute a function f with a single parameter in the cloud. To do so I defined the @Gridify -ed method myCloudExecutionMethod, which takes such a function and such a parameter.
package org.anddev.scala.gridgain

import org.gridgain.grid._
import org.gridgain.grid.gridify._

object MyGridifyApp {
 def main (args : Array[String]) : Unit = {
  try { 
   def f = (x:Int) => {println(">>> Executing f(x)=x*x ..."); x*x} 
   println(">>> f(5)=" + myCloudExecutionMethod(f, 5))  
  finally GridFactory.stop(true)  

 def myCloudExecutionMethod(f: Int => Int, x: Int): Int = {
  println(">>> myCloudExecutionMethod ...")  
This is how the whole project with all resources looks like (Note: MyGridApp, MyGridJob and MyGridTask are not used in this example):

When running the app you might need to create/modify the Run-Configuration, as the current Scala-Eclipse Plugin pretty much fails on creating one for you. (You'll probably have to enter the 'Main class' in the 'Main'-tab)

This is how the run configuration looks like, when you have set up your project correctly (See the screencasts on how to add what and where) :

So to actually run this awesome code on the grid, you'd start some grid-nodes (from sth. like: C:\Program Files (x86)\gridgain-2.1.1\bin ) then sth like this will be logged to your Eclipse Console view:

  _____      _     _  _____       _       
 / ____|    (_)   | |/ ____|     (_)      
| |  __ _ __ _  __| | |  __  __ _ _ _ __   
| | |_ | '__| |/ _` | | |_ |/ _` | | '_ \ 
| |__| | |  | | (_| | |__| | (_| | | | | | 
 \_____|_|  |_|\__,_|\_____|\__,_|_|_| |_|

>>> GridGain ver. 2.1.1-26022009
>>> Copyright (C) 2005-2009 GridGain Systems.

>>> -------------------
>>> Discovery Snapshot.
>>> -------------------
>>> Number of nodes: 3

>>> Total number of CPUs: 2

>>> --------------------------------------------------
>>> GridGain ver. 2.1.1-26022009 STARTED OK in 8466ms.
>>> --------------------------------------------------
>>> f(5)=25

>>> ------------------------------------------------
>>> GridGain ver. 2.1.1-26022009 STOPPED OK in 19ms.
>>> ------------------------------------------------
>>> Optional instance name: null
>>> Grid up time: 00:00:01:256
We can see that the result was actually printed in our application, just as we expected. And if you now have a look to the nodes you had started, you'll find the following in one of them:
>>> myCloudExecutionMethod ...
>>> Executing f(x)=x*x ...
Think about this for a moment.... BAZINGA! - You've just successfully executed your first Grid-enabled application.

As you also have seen, the screencasts show off some JUnit-love on GridGain and this is how you do it with Scala. Note: You'll have all the same buildpath-setup as above!

Basically we will have two TestCases and one of the will throw an Exception on purpose, so we can see that we can even view the proper stacktrace of a Exception that was thrown somewhere in the grid!!! (Both TestCases are wrapped in a TestSuite)

package org.anddev.scala.gridgain

import junit.framework._

class MyGridAppTestA extends TestCase {
    def testA() : Unit = {
        throw new RuntimeException("Exception in test A on " + ManagementFactory.getRuntimeMXBean().getName())
package org.anddev.scala.gridgain

import junit.framework._

class MyGridAppTestB extends TestCase {
    def testB() : Unit = {
        println("Executing test B on: " + ManagementFactory.getRuntimeMXBean().getName())
package org.anddev.scala.gridgain

import junit.framework._
import org.junit.runner.RunWith
import org.junit.runners.Suite
import org.gridgain.grid.test._
import org.gridgain.grid.test.junit4._

@Suite.SuiteClasses(Array(classOf[MyGridAppTestA], classOf[MyGridAppTestB]))
class MyGridAppTestSuite

In this case the Eclipse JUnit Runner could successfully pick up the TestSuite and I didn't even have to create a Run Configuration manually!

This is what we expected and what you will get:
As I said WIN ! GridGain rocks!

Hello Blogosphere World...

I started this blog, because I felt the urgent need to tell the world of what I do in my free time...
No seriously, once in a while there might appear some stuff that is of interest for others =)