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 ! _)
  }
}