FreeBSD 8.1 und die JVM

Alios hat gerade seinen Server auf den neusten Stand gebracht und prompt funktionierte Sakura natürlich wieder nicht. Das Problem war das die JVM wohl anscheinen den IPv6 Stack genommen hat und sich damit nicht verträgt, ein Workaround ist die JVM einfach dazu zu zwingen den IPv4 Stack zu nehmen. Das geht mit der -Djava.net.preferIPv4Stack=true Option.

Wenn euch also das nächste mal ein Socket beim Connect aus unerfindlichen Gründen abraucht, versucht es mal damit.

100 Posts!

Spass mit Scala Infixtypen

In Scala gibt es das interessante Konzept der Infix Typen, dabei handelt es sich um nichts weiter als Typen die zwei Parameter erwarten. Scala erlaubt hier Infix Notation.

object Main {
  class FooBar[A, B]

  def main(args: Array[String]): Unit = { 
    //zwei unterschiedliche Schreibweisen die das gleiche
    //meinen
    var x: FooBar[Int, BigInt] = null
    var y: Int FooBar BigInt   = null
  }
}

Damit eröffnen sich interessante Möglichkeiten des Typsystems, z.B: "Operatoren" aus Typen erstellen die wiederum Typen erstellen. Verwirrt? In Scala gibt es bereits =:=, <:< und <%<, diese Konstrukte kann man sich unter anderem auch selbst zusammenbasteln, im folgenden Beispiel bauen wir uns einen <@@@< "Operator"

abstract class <@@@<[A, B] extends (A => B)

class Test[T <: (Int => Int)]

object Main {
  def main(args: Array[String]) = { 
    val t = new Test[Int <@@@< Int]
  }
}

Ziemlich cool, jetzt kann man sich Operatoren basteln die Typen erstellen und sich anfühlen wie native Features der Sprache :)

Paralleles Primzahlsieb in Scala

Nach der Präsentation von Google Go habe ich mich gefragt ob man das parallele Primzahlsieb auch in Scala so machen kann. Ich muss sagen das ich das Resultat sogar einfacher und eleganter finde als die Go Implementation. Sicherlich gibt es performantere Algorithmen aber hier geht es einfach um das Prinzip zu zeigen wie einfach man Parallelisieren kann.

HINWEIS: Das Programm terminiert nicht, da für jede Primzahl ein eigener "Thread" (Actors die per react warten verhalten sich nicht ganz so wie Threads die in einem Loop warten, sondern sind leichtgewichtiger) gestartet wird und diese weiter auf Futter warten. Es ist auf jeden Fall möglich das das ganze anhält, ich will lediglich das Prinzip zeigen und das Beispiel nicht unnötig aufblasen.

import scala.actors.Actor
import scala.actors.Actor._

class Prime(value: Int) extends Actor {
  var next: Option[Prime] = None

  println(value)
  start

  def act(): Unit = loop {
      react {
        case x: Int if ((x % value) != 0) =>  
          next match {
            case Some(p: Prime) => p ! x 
            case None => next = Some(new Prime(x))
          }   
      }   
    }   
}

object Main {
  def main(args: Array[String]): Unit = { 
    val primer = new Prime(2)
    3 to args(0).toInt map (primer ! _)
  }
}

Mergesort in Scala

Und aus der Kategorie "Sortieren für Besessene" kommt heute mal wieder ein Beispiel, aber ausnahmsweise kein Quicksort ;)

Was ich besonders toll an diesem Beispiel finde ist das auf gleich 2 Listen gleichzeitig gematcht wird wie es auch in Haskell geht. Da hat Scala mal wieder richtig Spass gemacht.

object Main {

  def merge[T <% Ordered[T]](l: List[T], r: List[T]): List[T] = 
    (l,r) match {
      case (x::xs, y::ys) => if (x < y)
                               x::(merge(xs, r)) 
                             else
                               y::(merge(l, ys))
      case (xs,  Nil) => xs
      case (Nil, ys)  => ys
    }   

  def mergesort[T <% Ordered[T]](list: List[T]): List[T] =   
    if (list.length > 1) { 
      val (l, r) = list splitAt (list length)/2
      merge(mergesort(l), mergesort(r))
    } else list

  def main(args: Array[String]): Unit = { 
    println(mergesort(List(4,5,9,1,2,4,5,9,8,7)))
  }
}

Scala in der Warpzone

Scala in der warpzone Münster from raichoo on Vimeo.

Git-Mode für die KSH

Ich habe gerade mal meine Git Erweiterung für die Kornshell in meinen Bitbucket gestellt. Das ganze liegt zwar noch unter "Mercurial-Integration" aber sollte zu finden sein ;). Wie schon beim Mercurial mode wechselt man mit mode git in den entsprechenden Modus. Die Farbe der Commit ID wechselt von Rot (uncommited changes) zu Gelb (nicht die aktuellste Revision) zu Grün (aktuellste Revision und nichts zu commiten). Außerdem wird der aktuelle Branch angezeigt und im Falle eines "detached HEAD" Zustands visuell gewarnt. Viel Spass damit!