Compulsion to Code

An Akka actor from the cutting room floor

2011-07-01T09:04:00.001-05:00

This is an example of hot-swapping actor behavior in Akka using the become method. This demo was not part of my "Akka: Scaling Up and Out with Actors"(http://java.ociweb.com/javasig/knowledgebase/2011-06/index.html) talk given at the St. Louis JavaSIG on June 9th, 2011. It was left out due to time constraints on the presentation.

Inspired by a post on Dale Schumaker's "The Computational Actor's Guild" site (http://dalnefre.net/drupal/node/23), this demonstrates an actor that builds a ring of of actors of a specified size that then passes a message around the ring a given number of times. What's interesting about this implementation is that the actor uses become to change the behavior of a Actor from one that helps construct the ring to one that handles the message by passing to the next actor in the ring.

object RingBecomeDemo {

  class NodeActor(id:Int, start:Long) extends Actor {

    def receive = {
      case n:Int => self ! (self, n)
      case (top:ActorRef, n:Int) => {
        if (id == 0) {
          become {
            case np:Int => if (np == 0) {
                self.stop
                printf("Time %d ms\r\n", System.currentTimeMillis - start)
              } else {
                printf("decrementing from %d\r\n", np)
                top ! (np - 1)
              }
          }
          top ! n
        } else {
          val next = Actor.actorOf(new NodeActor(id-1, start)).start
          next ! (top, n)
          become {
            case np:Int => {
              next ! np
              if (np == 0) {
                self.stop
              }
            }
          }
        }
      }
    }
  }

  def main(args:Array[String]) {
    val ring = Actor.actorOf(new NodeActor(1000000, System.currentTimeMillis)).start
    ring ! 10
  }
}

This implementation creates a million nodes and times how long it takes to construct the ring and pass an integer around 10 times.

Here (http://sites.google.com/site/compulsiontocode/blog/ring-become.zip) is a file containing code above. Gradle is required to run it. To execute, unzip and enter 'gradle RingBecomeDemo' within the 'ring-become' directory.

One million node requires a significant heap size. To reduce the number nodes, change the first parameter passed to the NodeActor constructor. The heap size can be changed by editing the RingBecomeDemo task in the build.gradle file:

task RingBecomeDemo(type:JavaExec, dependsOn: classes) {
  jvmArgs = System.getProperty("sun.arch.data.model").equals("64") ? ["-Xms2048m", "-Xmx2048m"] : ["-Xms1024m", "-Xmx1024m", "-server"]
  classpath = sourceSets.main.runtimeClasspath
  main = "tfd.ringbecome.RingBecomeDemo"
}

A follow-up post is planned compare this implementation to one in Erlang including performance.

Fixing Gradle compileScala to not depend on compileJava

2011-05-20T22:52:00.001-05:00

One problem encountered using the Scala plugin for Gradle is that the 'compileScala' task is dependent on the 'compileJava' task (as of Gradle 0.9.2). If a project has both Java and Scala sources and there are Java classes that depend on Scala ones, the build will fail. Consider two mutually dependent classes in a the same project:

Bar.java

public class Bar {
    public void doFoo(Foo foo) { ... }
}

Foo.scala

class Foo {
  def doBar(bar:Bar) { ... }
}

Gradle can't build this because Bar depends on Foo which hasn't been compiled yet. However, the Scala compiler can handle cross compilation with Java sources, so the solution is simply let the Scala compile occur first.

To override the compileScala task dependency and reverse the order of the tasks add the following to the 'build.gradle' file:

compileScala.taskDependencies.values = compileScala.taskDependencies.values - 'compileJava'
compileJava.dependsOn compileScala

The first line removes the task dependency on the compileJava task from the compileScala task. The second line makes the compileJava task depend on compileScala.

For the Java source to be available for cross compilation the directory needs to in a "sourceSet" for the Gradle Scala plugin. For example, if the Java class is in 'src/main/java' then the following will need to be included in build.gradle:

sourceSets {
    main {
        scala {
            srcDir 'src/main/java'
        }
    }
}

Using this arrangement a project with mutual dependencies like the example above should be buildable with Gradle.

Enable a Scala compiler plugin using Gradle

2011-05-18T22:47:00.001-05:00

Having recently switched a Scala project to Gradle for building, I was faced with the difficulty of figuring out how to enable the Scala continuation plugin during the compileScala task. Below is a general solution I came up with. Hopefully it will be helpful for others and save someone some time.

apply plugin: 'scala'
...
configurations {
  scalaCompilerPlugins { transitive = false }
}

dependencies {
...
    scalaCompilerPlugins 'org.scala-lang.plugins:continuations:2.9.0' 
}

def scalacXPlugins() {
     return ((configurations.scalaCompilerPlugins.files.collect { "\"-Xplugin:${it.path}\"" }))
}

compileScala.scalaCompileOptions.additionalParameters = scalacXPlugins() + ['-P:continuations:enable']

The "transitive = false" in the configurations block prevents dependencies of the plugin as being treated as plugins themselves. Namely, the Scala compiler and library.

Code Kata for Parallel Programming

2010-10-29T06:50:00.010-05:00

One of the keynote presentations at the Strange Loop 2010 conference in St. Louis was
Guy Steele's "How to Think about Parallel Programming: Not!."

One of the examples in the presentation was counting words in a presumably large text file. He showed example code in Fortress of how one could go about taking a "divide-and-conquer" approach to the problem. This approach would divide the work into chunks that could be processed in parallel and then the outputs would be aggregated to form the solution.

Noticing some of the syntactic similarities between Fortress and Scala, I had the impulse to implement a solution in Scala. During Dean Wampler's "Scalable Concurrent Applications with Akka and Scala" talk, I got the idea that that would make a good code kata to use and learn Akka.

My final idea for the kata modifies the problem from counting words to finding sequences of digits where the last digit is the sum of its immediately preceding digits of any length. The input would be stream of non-zero digits. For example, the content below contains sequences "1326", "415", "246" and "617".


8745648184845171326578518184151512461752149647129746915414816354846454

Such "sum sequences" should be listed only once in the solution and in the order they are found in the input. Limiting the input to non-zero digits simplifies the problem a little bit since many consecutive zeros would produce a solution that will grow exponentially.

My initial implementations for this will use Scala and Akka including one using remote actors. Over the coming months, I hope to have time to implement solutions in other languages, such as F#, Clojure and Erlang, using their various parallel programming / concurrency libraries. Hopefully others will find this problem compelling and implement such solutions as well.

A Refactoring in Scala

2009-06-09T08:41:00.018-05:00

One pet project I have going is a little Logo interpreter done using Scala parser combinators with a Swing GUI where code can be edited and executed with results being rendered on a canvas. Being a good little Agile developer, I wrote automated tests for it

I've had experience on a previous Swing project using the Netbeans Jemmy library for driving the GUI tests in Java. I was curious of what Scala can wrap around such testing libraries like Jemmy. Initially, the test code was more Java style than Scala since I've only used Jemmy with Java previously. I found that interesting refactorings can be applied as the code takes on the more functional style of Scala.

Experienced Scala developers are probably familiar with these concepts, so the intended audience is developers who are relatively new to Scala and insights into why Scala code is the way it is.

As I was developing the tests, I needed to programatically find buttons on a toolbar that do such things as "New", "Save", "Load", and "Execute". These buttons don't have text, so I am using the tooltip to distinguish them. A Java-style Scala function to do this would look like this:


def findJButton(container:Container, toolTipText:String) = {
    val button = JButtonOperator.findJButton(container, 
        new ComponentChooser() {
            override def checkComponent(component:Component) = 
                if (component.getClass.isAssignableFrom(classOf[JButton])) {
                    component.asInstanceOf[JButton].getToolTipText == toolTipText
                } else {
                    false
                }
            override def getDescription() = "JButton Finder using toolTipText"
         }
    )
    if (button == null) {
        fail("cannot find JButton with tooltip = '" + toolTipText + "'")
    }
    new JButtonOperator(button)
}

Client code:


val newButtonOper = findJButton(frmOper.getContentPane, "Start new Logo program" )
val runButtonOper = findJButton(frmOper.getContentPane, "Run Logo program")

The "*Operator" classes in Jemmy wraps corresponding Swing components so that can be programatically manipulated in the same way an actual user would. The frmOper object is a Jemmy JFrameOperator that wraps the main frame of the application.

Now in Java, one can refactor the inner class into a regular class and leverage generics so that it can match any JComponent subtype since that is where getToolTipText is first implemented. In Scala, we will do something like that and make it so that a higher order function can be passed in the do the comparison provided the component is the correct type:


class LoanChooser[A <: java.awt.Component](clazz: Class[A], filter: A => Boolean) 
    extends ComponentChooser
{
    override def checkComponent(component:Component) = 
        if (component.getClass.isAssignableFrom(clazz)) {
            filter(component.asInstanceOf[A])
        } else {
            false
        }
    override def getDescription() = "Generic Finder using Loan Pattern"
}

def findJButton(container:Container, filter: JButton => Boolean) = {
    val button = JButtonOperator.findJButton(container,
                        new LoanChooser(classOf[JButton], filter))
    if (button == null) {
        fail("cannot find JButton with matching criteria")
    }
    new JButtonOperator(button)
}

Client code:


val newButtonOper = findJButton(frmOper.getContentPane, btn => btn.getToolTipText == "Start new Logo program" )
val runButtonOper = findJButton(frmOper.getContentPane, btn => btn.getToolTipText == "Run Logo program")

The code above uses the "Loan Pattern" in Scala (http://scala.sygneca.com/patterns/loan). The client code is loaned the the JButton instance so it can be tested to see if it matches the criteria.

Knowing the Scala implements functions as objects, I know that two identical anonymous function classes are going be created in the form "JButton => Boolean", so I create a common function that can be curried (or partially applied) with the toolTipText as the first parameter:


def toolTipTextEquals(toolTipText:String)(component:JComponent) = component.getToolTipText == toolTipText


val newButtonOper = findJButton(frmOper.getContentPane, toolTipTextEquals("Start new Logo program"))
val runButtonOper = findJButton(frmOper.getContentPane, toolTipTextEquals("Run Logo program"))

Now is getting pretty obvious what the code is trying to accomplish. There are some repeated code patterns that can be refactored out. At this point, it probably more at matter of taste in that some will want to refactor more and others might see it an an exercise in of "Scala Golf" (http://codegolf.com/). First we can get rid of the repeated "frmOper.getContentPane" by the traditional means of temporary local variable:


val contentPane = frmOper.getContentPane
val newButtonOper = findJButton(contentPane, toolTipTextEquals("Start new Logo program"))
val runButtonOper = findJButton(contentPane, toolTipTextEquals("Run Logo program"))

Or use an implicit conversion:


implicit def jFrameOperator2Container(frmOper:JFrameOperator) = frmOper.getContentPane


val newButtonOper = findJButton(frmOper, toolTipTextEquals("Start new Logo program"))
val runButtonOper = findJButton(frmOper, toolTipTextEquals("Run Logo program"))

The implicit conversion is invoked since the findJButton function it expecting a Container as the first param, but is provided a JFrameOperator. Since there is an implicit function in scope in the form "JFrameOperator => Container", it is used to perform the conversion implicitly.

My Logo application currently has four buttons on a toolbar that will need to be tested and I'll need JButtonOperators for all of them:


val newButtonOper = findJButton(frmOper, toolTipTextEquals("Start new Logo program"))
val openButtonOper = findJButton(frmOper, toolTipTextEquals("Open existing .logo file"))
val saveButtonOper = findJButton(frmOper, toolTipTextEquals("Save current logo code to file"))
val runButtonOper = findJButton(frmOper, toolTipTextEquals("Run Logo program"))

Once can utilize Scala's ability to deconstruct on patterns during declarations and do this:


val List(newButtonOper, openButtonOper, saveButtonOper, runButtonOper) = 
    List("Start new Logo program",
         "Open existing .logo file",
         "Save current logo code to file",
      "Run Logo program").map(toolTipText => findJButton(frmOper, toolTipTextEquals(toolTipText)))

It is a matter of taste whether four buttons warrant such refactoring, but if the code started to look unwieldy and I didn't want to keep them in some kind of collection, I would definitely consider this approach.

I felt this recent experience refactoring Scala code was interesting enough to blog about it and hope that readers gain some insight from this and want to use Scala more. I feel that Scala or at least a language with many of its features (like some kind of "Scala--") will play a big role on the JVM platform going forward.

Sidebar: Whither SQUIB

I haven't done much with the SQUIB project recently. I am seeing too many drawbacks to its approach:

Property resolution done at runtime - If the property is misspelled or uses an invalid type the best thing to do is fail fast and throw an exception. It would be nice if such issues could be detected at compile time at least.

Lack of IDE support - It would be nice if a framework uses actual methods that an IDE could then provide auto-completion and the like.

It's just a little heavyweight: I've found that very useful things can be done in Scala with minimal code.

Bowling in Yet Another Language (F#)

2009-03-10T21:56:00.012-05:00

Another day, another blog posting involving bowling and a functional programming language. This one is in F#, which is very interesting language for the .NET platform. Code:


#light

module Bowling 

open System;;

let scoreToInt x = 
    match x with
        Some y -> y
        | None -> -1;;

let rec tallyScores accum x = 
    match x with
        [] -> []
        | x::rest ->    let score = scoreToInt x in
                        if (score >= 0) then
                            let total = (accum + score) in total :: tallyScores total rest;
                        else
                            [];;

let rec take n l =
    if (n > 0) then
        match l with
            x::rest -> let newn = n-1 in x :: take newn rest
            |       [] -> []
        else
            [];;

let rec reduce f ys = 
    if ys <> [] then
        let (x, ys') = f ys in x::reduce f ys'
    else [];;

let scoreFrame rolls = 
    match rolls with
        x1::x2::x3::rest -> if (x1 = 10) then (Some (x1+x2+x3), x2::x3::rest)
                            else if (x1 + x2 = 10) then
                                (Some (x1+x2+x3), x3::rest)
                            else (Some(x1+x2), x3::rest)
        |   x1::x2::[] ->   if (x1 + x2 < 10) then
                                (Some(x1 + x2), [])
                            else (None, []);
        |   _ ->            (None, []);;
                            
let scoreTenFrames rolls =
    take 10 (reduce scoreFrame rolls);;
    
let tallyGame rolls = 
    tallyScores 0 (scoreTenFrames rolls);;
    
let printGame rolls = 
    List.iter (fun x -> Console.Write(int x); Console.Write " ") (tallyGame rolls);
        Console.Write "\n";;
    
let assertTrue expression = 
    if (expression = false) then 
        failwith "Assertion Not True";;
 
assertTrue ([30;60;90;120;150;180;210;240;270;300] = tallyGame[10;10;10;10;10;10;10;10;10;10;10;10]);;
assertTrue ([30;60;90;120;150;180;210;240;270;299] = tallyGame[10;10;10;10;10;10;10;10;10;10;10;9]);;
assertTrue ([30;60;90;120;150;180;210;240;270;290] = tallyGame[10;10;10;10;10;10;10;10;10;10;10;0]);;
assertTrue ([20;50;80;110;140;170;200;230;260;290] = tallyGame[9;1;10;10;10;10;10;10;10;10;10;10;10]);;
assertTrue ([30;60;90;120;150;180;210;240;269;289] = tallyGame[10;10;10;10;10;10;10;10;10;10;9;1]);;
assertTrue ([30;60;90;120;150;180;210;240;269;288] = tallyGame[10;10;10;10;10;10;10;10;10;10;9;0]);;
assertTrue ([30;60;90;120;150;180;210;240;260;280] = tallyGame[10;10;10;10;10;10;10;10;10;10;0;10]);;
assertTrue ([20;40;70;100;130;160;190;220;250;280] = tallyGame[10;9;1;10;10;10;10;10;10;10;10;10;10]);;
assertTrue ([30;60;90;120;150;180;210;239;259;279] = tallyGame[10;10;10;10;10;10;10;10;10;9;1;10]);;
assertTrue ([30;60;90;120;150;180;210;240;260;270] = tallyGame[10;10;10;10;10;10;10;10;10;10;0;0]);;
assertTrue ([20;40;60;80;100;120;140;160;180;200] = tallyGame[10;9;1;10;9;1;10;9;1;10;9;1;10;9;1;10]);;
assertTrue ([19;38;57;76;95;114;133;152;171;190] = tallyGame[9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;1;9]);;
assertTrue ([19;38;57;76;95;114;133;152;171;180] = tallyGame[9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;1;9;0]);;
// Partial games
assertTrue ([] = tallyGame[]);;
assertTrue ([] = tallyGame[0]);;
assertTrue ([] = tallyGame[9]);;
assertTrue ([] = tallyGame[10]);;
assertTrue ([] = tallyGame[9;1]);;
assertTrue ([] = tallyGame[10; 9]);;
assertTrue ([] = tallyGame[10; 10]);;
assertTrue ([0] = tallyGame[0; 0]);;
assertTrue ([1] = tallyGame[0; 1]);;
assertTrue ([9] = tallyGame[8; 1]);;
assertTrue ([9] = tallyGame[9; 0]);;
assertTrue ([19] = tallyGame[9; 1; 9]);;
assertTrue ([19; 28] = tallyGame[10; 9; 0]);;
assertTrue ([19; 28] = tallyGame[9; 1; 9; 0]);;
assertTrue ([20] = tallyGame[10; 9; 1]);;
assertTrue ([30] = tallyGame[10; 10; 10]);;
assertTrue ([30; 59] = tallyGame[10; 10; 10; 9]);;
assertTrue ([30; 59; 78; 87] = tallyGame[10; 10; 10; 9; 0]);;

Note that I've included a quick and dirty assertTrue method to validate the functions.

The above example can be used via the interactive shell (fsi) like below:


C:\DotNET\src>fsi

Microsoft F# Interactive, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.2, compiling for .NET Framework Version v2.0.50727

Please send bug reports to fsbugs@microsoft.com
For help type #help;;

> #load "bowling.fs";;
[Loading C:\DotNET\src\bowling.fs]

namespace FSI_0002
  val scoreToInt : int option -> int
  val tallyScores : int -> int option list -> int list
  val take : int -> 'a list -> 'a list
  val reduce : ('a list -> 'b * 'a list) -> 'a list -> 'b list
  val scoreFrame : int list -> int option * int list
  val scoreTenFrames : int list -> int option list
  val tallyGame : int list -> int list
  val printGame : int list -> unit
  val assertTrue : bool -> unit

> Bowling.printGame [10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10];;
30 60 90 120 150 180 210 240 270 300
val it : unit = ()
> Bowling.printGame [10; 9;1; 10; 9;0; 10; 8;2; 10; 10; 9;1; 9;1; 10];;
20 40 59 68 88 108 137 157 176 196
val it : unit = ()

Each element on the list represents a roll of the ball. The program will figure out which frames the rolls belong to. For example, "[9;1]" represents single frame consisting of a nine count followed by spare of the remaining pin. This implementation assumes valid input and is not designed to handle such things as more than 10 pins in a frame on a negative value for a roll.

Bowling with Clojure

2009-02-10T12:30:00.006-06:00

Having an interest in function programming languages (notably Scala), I decided to take a look at Clojure. In a nutshell, Clojure is a LISP variant that runs on the Java Virtual Machine and hence enjoys access to all libraries therein.
One of my favorite simple code katas with functional languages is to tally up bowling scores. Previously, I had done this with Erlang and Scala. Here is a Clojure version of the same including some tests:

(defn score-frame [rolls]
    (let [[x1 x2 x3] rolls]
        (cond   
            (nil? x1)           nil  
            (nil? x2)           nil                         
            (nil? x3)           (let [sumx (+ x1 x2)] 
                                    (if (< sumx 10) (list sumx)))       ; open at end of game                                                   
            (= x1 10)           (cons (+ x1 x2 x3) (rest rolls))        ; strike  
            (= (+ x1 x2) 10)    (cons (+ x1 x2 x3)  (nthrest rolls 2))  ; spare  
            (< (+ x1 x2) 10)    (cons (+ x1 x2) (nthrest rolls 2))      ; open  
            (true) nil  
        )
    )
)

(defn roll-reduce [remaining-rolls]  
    (if (not (= nil remaining-rolls))
        (let [result (score-frame remaining-rolls)]
        (if (not (= nil result)) 
            (cons (first result) (roll-reduce (rest result))))))
)        

(defn score-ten-frames [rolls]
 (take 10 (roll-reduce rolls)))

(defn tally-game [accum scores]
    (if (> (count scores) 0) (let [new_accum (+ accum (first scores))] (cons new_accum (tally-game new_accum (rest scores)))))
)

(defn score-game [rolls]
    (tally-game 0 (score-ten-frames rolls))
)

(assert (= '(30 60 90 120 150 180 210 240 270 300) (score-game '(10 10 10 10 10 10 10 10 10 10 10 10))))
(assert (= '(30 60 90 120 150 180 210 240 270 299) (score-game '(10 10 10 10 10 10 10 10 10 10 10 9))))
(assert (= '(30 60 90 120 150 180 210 240 270 290) (score-game '(10 10 10 10 10 10 10 10 10 10 10 0))))
(assert (= '(20 50 80 110 140 170 200 230 260 290) (score-game '(9 1 10 10 10 10 10 10 10 10 10 10 10))))
(assert (= '(30 60 90 120 150 180 210 240 269 289) (score-game '(10 10 10 10 10 10 10 10 10 10 9 1))))
(assert (= '(30 60 90 120 150 180 210 240 269 288) (score-game '(10 10 10 10 10 10 10 10 10 10 9 0))))
(assert (= '(30 60 90 120 150 180 210 240 260 280) (score-game '(10 10 10 10 10 10 10 10 10 10 0 10))))
(assert (= '(20 40 70 100 130 160 190 220 250 280) (score-game '(10 9 1 10 10 10 10 10 10 10 10 10 10))))
(assert (= '(30 60 90 120 150 180 210 239 259 279) (score-game '(10 10 10 10 10 10 10 10 10 9 1 10))))
(assert (= '(30 60 90 120 150 180 210 240 260 270) (score-game '(10 10 10 10 10 10 10 10 10 10 0 0))))
(assert (= '(20 40 60 80 100 120 140 160 180 200) (score-game '(10 9 1 10 9 1 10 9 1 10 9 1 10 9 1 10))))
(assert (= '(19 38 57 76 95 114 133 152 171 190) (score-game '(9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 1 9))))
(assert (= '(19 38 57 76 95 114 133 152 171 180) (score-game '(9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 1 9 0))))
(assert (= '(0 0 0 0 0 0 0 0 0 0) (score-ten-frames '(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))

; Partial games
(assert (= nil (score-game nil)))
(assert (= nil (score-game '(0))))
(assert (= nil (score-game '(9))))
(assert (= nil (score-game '(10))))
(assert (= nil (score-game '(9 1))))
(assert (= nil (score-game '(10 10))))
(assert (= '(0) (score-game '(0 0)))) 
(assert (= '(1) (score-game '(0 1))))
(assert (= '(9) (score-game '(8 1))))
(assert (= '(9) (score-game '(9 0))))
(assert (= '(19) (score-game '(9 1 9))))
(assert (= '(19 28) (score-game '(10 9 0))))
(assert (= '(19 28) (score-game '(9 1 9 0))))
(assert (= '(20) (score-game '(10 9 1))))
(assert (= '(30) (score-game '(10 10 10))))
(assert (= '(30 59) (score-game '(10 10 10 9))))
(assert (= '(30 59 78 87) (score-game '(10 10 10 9 0))))

Note this code has been updated since initial posting to incorporate changes based on feedback in a comment from Mark Volkmann below. Mark has published an excellent overview of Clojure here, http://www.ociweb.com/jnb/jnbMar2009.html

Link to code

Example:

C:\lang\clojure>java -jar clojure.jar bowling.clj
Clojure
user=> (score-game '(10 10 10 10 10 10 10 10 10 10 10 10))
(30 60 90 120 150 180 210 240 270 300)
user=> (score-game '(10 10 10 10 10 10 10 10 10 10 10 9))
(30 60 90 120 150 180 210 240 270 299)
user=> (score-game '(10 10 10 10 10 10 10 10 10 10 9 1))
(30 60 90 120 150 180 210 240 269 289)
user=> (score-game '(10 10 10 10 10 10 10 10 10 9 1 10))
(30 60 90 120 150 180 210 239 259 279)
user=> (score-game '(10 10 10 10 10 10 10 10 10 9 0))
(30 60 90 120 150 180 210 239 258 267)
user=> (score-game '(9 0 10 10 10 10 10 10 10 10 10 10 10))
(9 39 69 99 129 159 189 219 249 279)

SQUIB Google Group

2008-05-19T12:44:00.002-05:00

I should have done this a while ago. I've created a Google Group for discussion about the SQUIB project:

http://groups.google.com/group/scala-squib

SQUIB demos now "Web Start-able"

2008-03-06T12:30:00.000-06:00

I've packaged and signed the SQUIB libraries and the Scala 2.6.1 runtime to enable demos to executed via Java Web Start. My ISP doesn't send the appropriate MIME type to launch Web Start from JNLP links. To get around this, one can save the link to a local drive and (if they have the right file associations) launch the application. Another way, would be to use the command line using "javaws <JNLP URL>". Java version 1.5 or newer is required to launch these demos.

The first is the Scene Graph Intro program from a prior post, http://compulsiontocode.blogspot.com/2008/02/squib-kicks-part-1.html:

http://webpages.charter.net/daltontk/scala/scala_scenegraph_intro.jnlp

The second is a simple picture viewer inspired by the animated rotation done by Google Picasa. Image rotation is animated and done in 90 degree increments using translucent buttons in upper left corner of the image. Use the mouse wheel to zoom in and out.

http://webpages.charter.net/daltontk/scala/scala_squib_pictureviewer.jnlp

Link to source:

http://scala-squib.googlecode.com/svn/trunk/demo/src/tfd/scala/squib/demo/scenegraph/PictureViewer.scala

Screenshot:

SQUIB Kicks (Part 1)

2008-02-24T22:18:00.004-06:00

SQUIB (Scala's Quirky User Interface Builder) has been undergoing changes in the last month. New features include support for many event types beyond the simple ActionEvent. Instead of just showing cool things done using SQUIB (That will come later), I want to take a step back and a start a little tutorial on how to use SQUIB.

SQUIB gets its inspiration from JavaFX, but is not intended to be a clone of it. A design goal of SQUIB is to be lightweight, but enable developers to code GUIs in a more expressive manner with less lines of code.

For this tutorial, I've built a release and made it available at the project home on Google Code. Please download the main library jar, http://scala-squib.googlecode.com/files/scala_squibV0_4.jar.
SQUIB requires Scala 2.6 or later. I've only done basic validation the release candidates for Scala 2.7, but it seems to be working. The examples below will be Scala scripts instead of compiled applications to simplify execution by removing the compile step.

A "Hello World" frame


import tfd.scala.squib._

import javax.swing.WindowConstants

frame(
    attributes( 'title -> "Hello",
                'visible -> true,
                'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE),
    contents(   
        label(  attributes('text->"Hello World")    )
    )
).pack

link

To execute the script, save the source code to a file (for example "helloWorld.scalash") or download from the link, Ensure the scala_squibV0_4.jar is in the CLASSPATH, and invoke the script using "scala <saved source file>". Screenshot for the first example script:

SQUIB uses a helper object, attributes, to convert variable number of arguments into a list passed into an apply method of an object that constructs the component. Objects, frame and label, are used to construct JFrames and JLabels respectively. Originally, the apply method was overloaded to handle various combination of options. Eventually this got burdensome, so I made the apply methods use pattern matching of variable arguments and pretty much made attributes optional. For example, the code below doesn't use attributes:


import tfd.scala.squib._

import javax.swing.WindowConstants

frame(
      'title -> "Hello",
      'visible -> true,
      'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
      contents(
                label('text->"Hello World Again!"))
).pack

link
Screenshot:

Attributes names are not case sensitive. Setter methods corresponding to the attributes are invoked on the event queue via invokeAndWait if the current thread is not the event dispatch thread.

Buttons and Events

The next example is a button that simply changes its text when pressed:


import tfd.scala.squib._

import java.awt.event.ActionEvent
import javax.swing.{JButton, WindowConstants}

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    contents(
        button(
            'text->"Press Me",
            events (
                'actionPerformed -> { ae:ActionEvent =>
                    ae.getSource.asInstanceOf[JButton].setText("Pressed")
                }
            )
        )
    )
).pack

link

Screenshots before and after button pressed:

Event names are not case sensitive using this notation. Like attributes, events is also pretty much optional as well. However, there is one tiny risk. The pattern matcher could mistake an attribute for an event if by small chance, there is an attribute that is a Scala Function1[EventObject] object. This could not happen with an existing Swing component, but only with a custom component developed in Scala. The risk is very small and can be avoided by using events. Here is the equivalent code sans events:


import tfd.scala.squib._

import java.awt.event.ActionEvent
import javax.swing.{JButton, WindowConstants}

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    contents(
        button(
            'text->"Press Me",
            'actionPerformed -> { ae:ActionEvent =>
                ae.getSource.asInstanceOf[JButton].setText("Pressed")
            }
        )
    )
).pack

link

Since there are a finite number of events within Swing, SQUIB has helper/factory objects for the most common events. Being the name of an object, the event specification does become case sensitive. Here an a example that uses such a helper for the actionPerformed event which is in the tfd.scala.squib.event package:


import tfd.scala.squib._
import tfd.scala.squib.event._

import java.awt.event.ActionEvent
import javax.swing.{JButton, WindowConstants}

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    contents(
        button(
            'text->"Press Me",
            actionPerformed { ae:ActionEvent =>
                ae.getSource.asInstanceOf[JButton].setText("Pressed")
            }
        )
    )
).pack

link

The actionPerformed object makes the code a little tidier. Another benefit is that they can be passed a block without the EventObject parameter for those cases where the event handler is not "interested" in it. Example:

import tfd.scala.squib._
import tfd.scala.squib.event._

import javax.swing.{JButton, WindowConstants}
 
var clickCount = 0;

def clickCountText = "ClickCount: " + clickCount

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    'layout->gridlayout('rows->2, 'columns->1),
    contents(
        button('text->"Press Me",
            actionPerformed { 
                clickCount += 1
                label.id("clickCount").setText(clickCountText)
            }
        ),
        label("clickCount", 'text->clickCountText)
    )
).pack

link
Screenshot:

Removing the unneeded "ActionEvent:ae => " cleans up the code even more. This example also introduces the concept of component ids. Every SQUIB component object (like "label", "button" or "frame") keeps a map of components indexed by a String. The "id" method takes a String and returns the last component of that type constructed with that id (if there is any). Each component type has a different map, so different component types can have the same id. In the previous example, looking up the id during every event is not optimal, since the event handlers are lexically scoped closures, that can access values or variables within the current scope requiring the lookup to be performed only once. Example:


import tfd.scala.squib._
import tfd.scala.squib.event._

import javax.swing.{JButton, WindowConstants}
 
var clickCount = 0;

def clickCountText = "ClickCount: " + clickCount

lazy val clickCountLabel = label.id("clickCount")

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    'layout->gridlayout('rows->2, 'columns->1),
    contents(
        button('text->"Press Me",
            actionPerformed { 
                clickCount += 1
                clickCountLabel.setText(clickCountText)
            }
        ),
        label("clickCount", 'text->clickCountText)
    )
).pack

link

Since the label id is not set until after the block declaration, the val needs to be "lazy", so that it is not instantiated until the first time it is needed in the button event handler. Use of "lazy" is very helpful for SQUIB applications, because of situations like this.

If one doesn't want to use an id, the component itself can be referenced by a value and used:


import tfd.scala.squib._
import tfd.scala.squib.event._

import javax.swing.{JButton, WindowConstants}
 
var clickCount = 0;

def clickCountText = "ClickCount: " + clickCount

val clickCountLabel = label("clickCount", 'text->clickCountText)

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    'layout->gridlayout('rows->2, 'columns->1),
    contents(
        button('text->"Press Me",
            actionPerformed { 
                clickCount += 1
                clickCountLabel.setText(clickCountText)
            }
        ),
        clickCountLabel
    )
).pack

link

Here is one last example of a button with mouse event handlers:


import tfd.scala.squib._
import tfd.scala.squib.event._

import javax.swing.{JButton, WindowConstants}

val defaultButtonText = "Please Press Me"

lazy val pressMeButton = button.id("pressMe")

frame(
    'title -> "Press Me",
    'visible -> true,
    'defaultCloseOperation -> WindowConstants.DISPOSE_ON_CLOSE,
    contents(
        button("pressMe",
            'text->defaultButtonText,
            actionPerformed { 
                pressMeButton.setText("Ouch !!!!")
            },
            mouseEntered {
                pressMeButton.setText("Don't Press Me")
            },
            mouseExited {
                pressMeButton.setText(defaultButtonText)
            }
        )
    )
).pack

link
Screenshots before and after the mouse entered the component:

Currently, not all events are supported by SQUIB. For example, HierarchyEvent is not supported. In the those cases, one would have to implement a HierarchyListener in the same manner as Java. Supported events are ActionEvent, ChangeEvent, ComponentEvent, FocusEvent, InternalFrameEvent, ItemEvent, KeyEvent, ListSelectionEvent, MouseEvent, MouseWheelEvent, and WindowEvent.

This should pretty good starting point for how to use the SQUIB library. There will be future posts that will demonstrate other aspects including layouts and the SceneGraph library.

"Cool Thing" for this post

I've created a version of a SceneGraph demo named "Intro". The Java version is demonstrated here, https://scenegraph-demos.dev.java.net/demos.html.
There is an also a link to the source on the demo page.
The Scala source can be viewed here, http://scala-squib.googlecode.com/svn/trunk/demo/src/tfd/scala/squib/demo/scenegraph/Intro.scala.
To execute the demo, one needs the scala_squibV0_4.jar linked above and the jar with SQUIB SceneGraph support downloaded from http://scala-squib.googlecode.com/files/scala_squib_scenegraphV0_4.jar. Also, required is the archive containing the SceneGraph library itself available here, http://download.java.net/javadesktop/scenario/releases/0.5/Scenario-0.5.jar , and a jar containing the compiled application and resources downloaded from
http://scala-squib.googlecode.com/files/scala_scenegraph_intro.jar. Execute via:

scala -cp scala_squibV0_4.jar;scala_squib_scenegraphV0_4.jar;Scenario-0.5.jar;scala_scenegraph_intro.jar tfd.scala.squib.demo.scenegraph.Intro

Screenshot of the SQUIB application which is pretty much identical to the Java version on the SceneGraph demos page:

I'll let readers draw their own conclusions comparing the Scala/SQUIB code with the Java code for the application.

My own experience with Scala was that at first, I found the syntax kind of "wonky", but once I got used to it, I found it to be well thought out and even intuitive. Features like type inference and first class function objects are sorely missed at times when developing in Java at work.

SQUIB on Google Code

2008-01-16T00:30:00.002-06:00

I am happy to announce that Scala's Quirky User Interface Builder (SQUIB) is now a Google Code project. The project home page is http://code.google.com/p/scala-squib/.
A Subversion client is required to get the latest source from the trunk. To check out a copy of the current source use:

svn checkout http://scala-squib.googlecode.com/svn/trunk/ scala-squib-read-only

If you don't have a Subversion client, a snapshot from 1/16/08 is made available here . Of course using a Subversion client allows one to stay in sync with updates to the project via "svn update".

Requirements for SQUIB is Scala version 2.6 or later and a JRE version 1.5 or later. I've only used 1.6 for SQUIB, but there shouldn't be any problem using 1.5. Please let me know if there are issues. To build the project, Ant 1.6 or later is required.

There is a README.txt file on the root directory of the project that gives a quick run down of ant tasks available and demo programs currently in the project.

Currently, the scaladoc API documentation is rather thin, so in the near term, I will focused on getting more API documentation in the source code, so re-run "ant doc" after any Subversion update for updated documentation.

Please feel free to provide me feedback about this library. This is my first open source project that I've owned. What I have so far is just a start and there is lot of functionality yet to be added. I will be looking for new members for the project in the near future.

GUI Building with Scala - Part 3 (SQUIB and Scene Graphs)

2007-12-22T13:03:00.002-06:00

I have opted to rename this little project from the rather generic, "Scala Gui Builder" to SQUIB (Scala's Quirky User Interface Builder). Originally, I was going to demonstrate little custom components I had developed to be used by SQUIB to draw shapes, but when I saw the announcement of the Java Scene Graph library (https://scenegraph.dev.java.net/), it was clear that it a perfect fit for SQUIB.

I have just started development of Scene Graph support for SQUIB, so only minimal features are supported. Additionally, the Scene Graphs APIs are not finalized yet, so it would be not feasible to try to create a complete library against a changing API.

A Simple Example

I have created example programs to demonstrate the potential for Scene Graphs in SQUIB. Requirements for SQUIB with Scene Graph support are the updated SQUIB jar file
and the Scene Graph jar file. Here
is a link to the source for the first example or you could copy and paste from below. Compile and run:

C:\tmp>scalac -cp ScalaSquibV0_3.jar;Scenario-0.4.jar SceneGraphSimple.scala

C:\tmp\scala -cp .;ScalaSquibV0_3.jar;Scenario-0.4.jar tfd.scala.squib.scenegraph.demo.SceneGraphSimple

Source Code:


package tfd.scala.squib.scenegraph.demo;

import java.awt.{Color, Point, Font, Dimension, Rectangle, BasicStroke}
import javax.swing.{JFrame}

import com.sun.scenario.scenegraph._
import com.sun.scenario.animation._

import tfd.scala.squib._
import tfd.scala.squib.scenegraph._

object SceneGraphSimple extends Application {
    text.attributesDefault = attributes(
            'font -> new Font("Courier", Font.BOLD, 24),
            'mode -> SGAbstractShape.Mode.FILL,
            'fillPaint -> Color.BLUE
    )
    
    val frm = frame(
            attributes(
                    'title->"SQUIB Scenegraph Demo",
                    'visible -> true,
                    'defaultCloseOperation -> JFrame.EXIT_ON_CLOSE,
                    'size -> new Dimension(100,200)
             ),
             borderlayout(),
                 contents(
                     scenepanel("scene",
                         'scene -> group("root",
                                       group("sub",
                                           translate(50, 100, 
                                               rotate("square", 0.0,
                                                   shape(
                                                         'shape -> new Rectangle(-20,-20,40,40),
                                                         'mode -> SGAbstractShape.Mode.STROKE_FILL,
                                                         'fillPaint -> Color.RED,
                                                         'drawPaint -> Color.ORANGE,
                                                         'drawStroke -> new BasicStroke(5.0f)
                                                   )
                                               )
                                           ),
                                           scale("blah", 1.0, 1.0, 
                                               text("blah",
                                                    'text -> "Blah",
                                                    'location -> new Point(10,20)
                                               )
                                           ),
                                           translate(10, 110,
                                               composite(0.75, 
                                                   component('component -> button("FooBar"))
                                               )
                    )
                                       )
                         ),
                         'background -> Color.GREEN
                     ) -> "Center"
                 )
    )
    
    Clip.create(
            500,
            600.0,
            rotate.id("square"), 
            "rotation", 
            Array(-3.14159f, 3.14159f).map(_.asInstanceOf[Object]) 
    ).start();
    
    Clip.create(
            500, 
            900.0,
            scale.id("blah"), 
            "scaleY",
            Array(0.5f, 5.0f).map(_.asInstanceOf[Object]) 
    ).start();
}

Screenshot of Simple Example:

The Array(0.5f, 5.0f).map(_.asInstanceOf[Object]) expression represents one of the few areas where Scala/Java integration is not seamless. Scala does not handle Java variable arguments and "sees" the signature of the method as requiring an Array. The Scala code needs to explicitly put those parameters into an Array. Perhaps this could be done by an implicit conversion ? I'll have to experiment sometime.

A Spinning Calculator?

This is a little more elaborate example that embeds the calculator from a previous
post in a scene graph. Source is available here
. Compile and run:

C:\tmp>scalac -cp ScalaSquibV0_3.jar;Scenario-0.4.jar RotatingCalculator.scala

C:\tmp\scala -cp .;ScalaSquibV0_3.jar;Scenario-0.4.jar tfd.scala.squib.scenegraph.demo.RotatingCalculator

Screenshot of Rotating Calculator:

Looking at the RotatingCalculator source, you will see new button factory methods that allow definition of Actions in the button declaration itself and other "shorthand" methods. I am still planning to get the source out on Google Code in the coming months.

The examples here show the power of the Scene Graph library and how SQUIB can be used to generate scene graphs in Scala in a rather expressive manner.

GUI Building with Scala - Part 2

2007-11-21T08:39:00.002-06:00

In my previous post, http://compulsiontocode.blogspot.com/2007/10/gui-building-with-scala.html, I introduced a library for building Swing interfaces in Scala that I've been creating. This post will show more features of the library and demonstrate them by building a rudimentary calculator.

Based on feedback received, features have been added since the previous post, so a new version of library is made available here
along with source for the calculator.
Ensure the jar above is on the CLASSPATH, compile and run the example program:

C:\tmp>scalac -cp ScalaGuiBuilderV0_2.jar GuiBuilderCalc.scala

C:\tmp\scala -cp .;ScalaGuiBuilderV0_2.jar tfd.scala.guibuilder.demo.GuiBuilderCalc

Here is a screenshot of the calculator:

Summary of the GuiBuilderCalc.scala source:

The first piece of noteworthy code is below:

frame.attributes_default = attributes('defaultcloseoperation->JFrame.EXIT_ON_CLOSE)

button.attributesDefault = attributes('foreground->Color.blue)

button.attributesByPattern += ("\\d" -> attributes('foreground->Color.red))

The "attributesDefault" property of the component objects stores attribute mappings to be applied to any instance of the component thereafter. The first two lines above ensure that all frames created thereafter exit on close and all buttons created thereafter have blue text.

The "attributesByPattern" property stores a mapping of strings to attribute mappings that are applied to components whose id match the regular expression in the string key. It's kind of a "pseudo CSS". The last line above specifies that any button whose id is a single digit should have red text. The "attributesByPattern" are applied after the "attributesDefault" and therefore have precedence.

The next thing done in the code is create the textfield:

val calcField = textfield(
     'text->"0"
    ,'horizontalalignment->SwingConstants.RIGHT
    ,'editable->false
    ,'background->Color.white
)

Based on feedback from the last post, I made it optional to explicitly specify "attributes" when the attributes are the last parameter. The code above creates a JTextField without a string id, with specified attributes, and assigns it to value "calcField".

Below the panel containing the calculator buttons is created:

val gridPanel = panel(
     gridlayout('rows->5, 'columns->4, 'vgap->4, 'hgap->2)
    ,contents(
        button("clear"      ,'text->"C" , 'foreground->Color.black)
       ,button("clear_erase",'text->"CE", 'foreground->Color.black)
       ,new JLabel("")
       ,button("/","/")
       ,button("7","7")
       ,button("8","8")
       ,button("9","9")
       ,button("*","*")
       ,button("4","4")
       ,button("5","5")
       ,button("6","6")
       ,button("-","-")
       ,button("1","1")
       ,button("2","2")
       ,button("3","3")
       ,button("+","+")
       ,button("0","0")
       ,button("negate","+/-")
       ,button(".",".")
       ,button("=","=") 
    )    
)

I've added factory methods for the button component to cover the more common of component construction scenarios. For example, button("+","+") creates a button with string id of "+" and "+" for the text. This can also be expressed as button("+", 'text->"+") or even button("+", attributes('text->"+")).

The new JLabel("") part shows that you can create Swing components using the normal constructors and include them. This allows custom components to be built into the interface. Components included this way can not have string ids nor do "attributesDefault" or "attributesByPattern" get applied to them.

The textfield and buttons are assembled together in a panel:

val frm = frame(
    attributes(
      'title->"GUIBuilder Calculator"
    )
   ,borderlayout()
   ,contents(
        panel(
             borderlayout()
            ,contents(
                 calcField -> "North"
                ,gridPanel -> "Center"
            )
        ) -> "Center"
   )
)

Here components in the contents need constraints due to the use of borderlayout. In Scala, the expression "foo -> bar" is simply a tuple so (calcField, "North") and (gridPanel, "Center") could also have been used.

Finally, button handlers are added.

var stored = 0.0
var operation = ' '
var newInput = true

// Iterate and attach event handlers for the number buttons
for (val num<-Iterator.range(0, 10)) {  
    button.onAction("" + num,(ae: ActionEvent) => {
        val prepend = if (newInput) "" else calcField.getText
        calcField.setText(prepend + num)
        newInput = false
    })
}

// Attach an event handling to clear the sum text field
button.onAction("clear", (ae: ActionEvent) => {
    calcField.setText("0")
    newInput = true
})

button.onAction("clear_erase", (ae: ActionEvent) => {
    calcField.setText("0")
    stored = 0.0
    newInput = true
})

button.onAction("negate", (ae: ActionEvent) => {
    calcField.setText("" + (-calcField.getText().toDouble))
})

button.onAction(".", (ae: ActionEvent) => {
    if (newInput) {
        calcField.setText("0.")
        newInput = false;
    } else {
        val text = calcField.getText()
        if (!text.contains('.')) {
            calcField.setText(text + ".")
        }
    }
})

def doOperation(oper:Char) {
    operation = oper
    stored = calcField.getText().toDouble
    newInput = true
}

button.onAction("+", (ae: ActionEvent) => {
    doOperation('+')
})

button.onAction("-", (ae: ActionEvent) => {
    doOperation('-')
})

button.onAction("*", (ae: ActionEvent) => {
    doOperation('*')
})

button.onAction("/", (ae: ActionEvent) => {
    doOperation('/')
})

button.onAction("=", (ae: ActionEvent) => {
    val current = calcField.getText().toDouble
    calcField.setText("" + (operation match {
        case '+' =>  (stored + current)
        case '*' =>  (stored * current)
        case '-' =>  (stored - current)
        case '/' =>  (stored / current)
        case _ => current
    }))
    newInput = true
})

The library continues to grow based on feedback from others and from my own ideas. There are still features already built in to be shown in future posts. At some point, I am hoping to release the source and create a project on SourceForge or Google Code. The name "Scala GUI Builder" is not very original. Shortening "SCala User Inteface Builder" makes "SCUIB" which isn't a word. I am liking "SQUIB" for "Scala Quick User Interface Builder".

GUI Building with Scala

2007-11-14T07:44:00.004-06:00

One the strengths of Scala is a flexible syntax that allows for Scala code be more like a Domain Specific Language. A while back, I started to put such a Scala "DSL" together inspired in part by what was then known as F3, but has since been re-branded, JavaFX. This idea languished for few months while I got distracted by other pursuits. I've decided to publish what I have produced so far to get feedback about it and determine if such a thing is a worth continuing.

I've published the supporting classes in a jar file available here
along with a simple example program. Ensure the jar above is on the CLASSPATH, compile and run the example program:

C:\tmp>scalac -cp ScalaGuiBuilderV0_1.jar GuiBuilderSimple.scala

C:\tmp\scala -cp .;ScalaGuiBuilderV0_1.jar tfd.scala.guibuilder.demo.GuiBuilderSimple

Simple Example Code:

package tfd.scala.guibuilder.demo

object GuiBuilderSimple extends Application {
  import java.awt.{Color, FlowLayout}
  import java.awt.event.ActionEvent
  import javax.swing.JFrame

  import tfd.scala.guibuilder._

  var frm = frame(
                attributes(
                   'title->"GUIBuilder Simple Demo",
                   'defaultCloseOperation->JFrame.EXIT_ON_CLOSE
                ),
                flowlayout(attributes('alignment -> FlowLayout.LEFT)),
                contents(
                    button("PressButton", attributes('text->"Press"   ,'foreground->Color.blue)),
                    label("PressLabel",   attributes('text->"Not Pressed",'foreground->Color.red))
                )
  )

  button.onAction("PressButton",(ae: ActionEvent) => {
      label.applyAttributes("PressLabel", attributes('text -> "Pressed", 'foreground -> Color.black))
  })

  frm.pack
  frm.setVisible(true)
}

Running the program will create a window like the first one below:

Before the button is pressed

After the button is pressed

So what's going on here ? Each component is represented by a Scala object with overloaded "apply" methods that represent various options of constructing the component. In other words, they are factories. To prevent confusion or collisions with existing class names, the component objects names are all lowercase. If "Frame" was used instead of "frame" then it becomes unwieldy if the program wants to "import java.awt.Frame". The "attributes" are also processed by a factory object via its "apply" method. I could have used "List(<attribute1>,<attribute2>...)" or "<attribute1> :: <attribute2> ... :: Nil", for listing the attributes, but I feel it's more concise to use "attributes". It would be nice if Scala supported lists in more shorthanded way like Erlang or Ocaml then I could have done something like "[<attribute1>,<attribute2>...]".

I opted to use Scala symbols for the attribute names to save a keystroke and reduce problems from trailing quotes being omitted. Using strings would have required code like:

attributes(
  "title"->"GUIBuilder Simple Demo",
  "defaultCloseOperation"->JFrame.EXIT_ON_CLOSE
)

Feedback on the using string versus symbols would be appreciated.

Let's break down what is going on in the sample above:

The "frame" factory object returns the JFrame it constructed and takes the following parameters:
- The "attributes" represent mappings of bean properties to values. The library will use introspection to look for get methods to invoke in order to set the attribute.
- A layout manager specification. Here the "flowlayout" object will return a java.awt.Flowlayout to be used for the content pane of the frame.
- The "contents" object specifies the components to be added to the frame's content pane using the specified layout manager. Here, since we are using a FlowLayout, we don't need to provide constraints for the layout manager in the contents. Using more complicated layout managers will require such constraints in the contents.
- The components added here are simply a button and label which map to Swing JButton and JLabel components respectively. The first parameter passed to their "constructor" object is an optional string identifier that allows the component to be looked up later using an "id" method on the factory object. Example 'var btn = button.id("PressButton")' will assign the JButton with id of "PressButton" to variable "btn".

The button.onAction method takes the string id for the button and function object with an ActionEvent parameter and adds an ActionListener to the button that delegates it's actionPerformed call to the passed function object. The body of the function object invokes an applyAttributes method on the label applies attribute to a label specifies by the string id. The same can can accomplished in a more Java like style with the code below:
```
button.onAction("PressButton",(ae: ActionEvent) => {
  var label = label.id("PressLabel")
  label.setText("Pressed")
  label.setForeground(Color.black)
})
```

Finally, the JFrame is packed and made visible.

As of yet, the library only supports a subset of the Swing components. I plan to follow up with more posts shortly with examples showing how to use constrained components in frames and panels with other layout managers (including GridBagLayout), show more supported component types and other features I have built into the library. I will also publish the source for the library.

Extending the properties.scala Example

2007-10-25T09:45:00.005-05:00

I was tinkering with the properties.scala example (http://www.scala-lang.org/docu/examples/files/properties.html) from the main Scala site. One thing that occurred to me was that the functionality to automatically fire PropertyChange events could be added such a way that implementers would only need to the to use a trait and specify member properties.
I'd originally called this concept "BeanProperty", but to prevent confusion with the Scala annotation of the same name, it's named "BindableProperty". Such as class could form the basis of some kind of property binding arrangement.

Here is a example of a class with BindableProperties:


class BindableUser extends hasBindableProperties {
    val firstName = BindableProperty("firstName","")
      .onGet { v => v.toUpperCase() }
      .onSet { v => if (v == null) 
                        throw new IllegalArgumentException("firstName can not be set to null");
                    }
                        v
                    }
              }
    val lastName = BindableProperty("lastName", "")
    
    val employeeNbr = BindableProperty[Long]("employeeNbr") 
    
    var isMarried = BindableProperty[Option[Boolean]]("isMarried", None)
    
    var isMale = BindableProperty[Boolean]("isMale")
         .onSet { v => updateSalutation(v, isMarried()); v }
    
    var salutation = BindableProperty[String]("saluation");
    
    // Some some reason, this needed to be after isMale declaration   
    isMarried.onSet { v => updateSalutation(isMale(), v); v }

    private def updateSalutation(male:Boolean, married:Option[Boolean]):Unit = {
         Console.println("update salutation " + (male, married))
         salutation := ((male, married) match {
             case (true,_) => "Mr."
             case (false,Some(true)) => "Mrs."
             case (false,Some(false)) => "Miss."
             case (false,None) => "Ms."
             case _ => ""
         })
    }
    
    override def toString() = salutation() + " " + firstName() + " " + lastName() + ":" + employeeNbr()
}

    The hasBindableProperties trait provide methods for creation of BindableProperties and a map to store PropertyChangeListeners much like the PropertyChangeSupport class in Java.
    The onGet and onSet methods are used to specify a block of code that can transform or validate data. Above, the onGet method method converts the stored property to uppercase upon retrieval. The isMale and isMarried properties have onSet handlers that try to infer the salutation based on gender and marital status (i.e. "Mr.", "Mrs.", "Miss.", or "Ms."). The onSet handler for firstName throws an Exception if value passed is null.
    The second parameter of the BindableProperty method specifies an initial value. If an initial value is not specified, the type for the property can not be inferred and the type parameter must be specified like how it is done for the employeeNbr property in the code above.

    There are multiple ways to set a property. This is done because tastes may vary on what is readable and some people may dislike anything resembling operator overloading. Examples of setting a property:


val zaphod = new BindableUser()
// Different ways to set
zaphod.firstName("Zafod")
zaphod.lastName.set("Beeblebrox")
zaphod.isMale := true
zaphod.employeeNbr() = 0

The ":=" is the result of a flashback to Pascal that I learned in college.

There are two ways to get a property:


Console.println("user first name: " + user.firstName())
Console.println("user last name: " + user.lastName.get())

Here's an example of a PropertyChangeListener that simply reports the change to the console:


class TestBindablePropertyChangeListener extends PropertyChangeListener {
    override def propertyChange(evt: PropertyChangeEvent) = 
        Console.println(String.format("Property '%s' for object '%s' changed from '%s' to '%s'", List(
                 evt.getPropertyName()
                ,evt.getSource().toString()
                ,evt.getOldValue()
                ,evt.getNewValue()
          ).toArray)) // Scala varargs are different from Java
                     // Had to explicitly pass an array for the Java varargs
}

To add the listener to a given object::


zaphod.addPropertyChangeListener(new TestBindablePropertyChangeListener())

Now when a property changes for a user, it is detected and reported on the console:

Example:
To see this in action, download the BindableProperties source here and demo source here.
Compile the BindableProperties.scala first and it will create classes in directory, ./tfd/scala/bindableproperties. Secondly, compile the BindablePropertiesDemo.scala and it will put classes in ./tfd/scala/bindableproperties/demo directory. The above BindableUser and TestBindablePropertyChangeListener are included in the demo source. From the base directory, the scala interpreter can be invoked:


C:\stuff\mycode\trunk\scala\src>scala
Welcome to Scala version 2.6.0-final.
Type in expressions to have them evaluated.
Type :help for more information.

scala>import tfd.scala.bindableproperties.demo._
import tfd.scala.bindableproperties.demo._
 
scala>val zaphod = new BindableUser()
 
scala>zaphod.firstName("Zafod")
 
scala>zaphod.lastName.set("Beeblebrox")
 
scala>zaphod.isMale := true
update salutation (true,None)
 
scala>zaphod.employeeNbr() = 0
    
scala>Console.println(zaphod.toString)
Mr. ZAFOD Beeblebrox:0
 
scala>zaphod.addPropertyChangeListener(new TestBindablePropertyChangeListener())
 
scala>zaphod.firstName := "Zaphod"
Property 'firstName' for object 'Mr. ZAPHOD Beeblebrox:0' changed from 'Zafod' to 'Zaphod'
 
scala>zaphod.salutation := "Part-time Galactic President"
Property 'saluation' for object 'Part-time Galactic President ZAPHOD Beeblebrox:0' changed from 'Mr.' to 'Part-time Galactic President'
 
scala>Console.println(zaphod.toString)
Part-time Galactic President ZAPHOD Beeblebrox:0
 
scala>val trillian = new BindableUser()
 
scala>trillian.firstName := "Trisha" 
    
scala>trillian.lastName := "McMillan" 
    
scala>trillian.isMale := false
update salutation (false,None)
 
scala>trillian.employeeNbr := 22079460347L
 
scala>Console.println(trillian.toString)
Ms. TRISHA McMillan:22079460347
 
scala>trillian.addPropertyChangeListener(new TestBindablePropertyChangeListener())
   
scala>trillian.firstName := "Trillian"
Property 'firstName' for object 'Ms. TRILLIAN McMillan:22079460347' changed from 'Trisha' to 'Trillian'
    
scala>trillian.lastName := "" 
Property 'lastName' for object 'Ms. TRILLIAN :22079460347' changed from 'McMillan' to ''
 
scala>trillian.employeeNbr := 42
Property 'employeeNbr' for object 'Ms. TRILLIAN :42' changed from '22079460347' to '42'
 
scala>trillian.isMarried := Some(false);
Property 'isMarried' for object 'Miss. TRILLIAN :42' changed from 'None' to 'Some(false)'
 
scala>Console.println(trillian.toString)
Miss. TRILLIAN :42
 
scala>trillian.lastName := "Dent"
Property 'lastName' for object 'Miss. TRILLIAN Dent:42' changed from '' to 'Dent'
 
scala>trillian.isMarried := Some(true)
update salutation (false,Some(true))
Property 'salutation' for object 'Mrs. TRILLIAN Dent:42' changed from 'Miss.' to 'Mrs.'
Property 'isMarried' for object 'Mrs. TRILLIAN Dent:42' changed from 'Some(false)' to 'Some(true)'
 
scala>Console.println(trillian.toString)
Mrs. TRILLIAN Dent:42

I've also included a demo application in the BindablePropertiesDemo.scala file, BindablePropertiesDemo that can invoked via "scala tfd.scala.bindableproperties.demo.BindablePropertiesDemo". This demo runs the above commands and has a try/catch block where a firstName property is set to null.
Scala's flexible syntax provides a good basis for creating new idioms that can make code more expressive and DSL-like without losing static typing and be a compiled language.

Bowling with Erlang and Scala

2007-05-25T21:20:00.013-05:00

I read an blog entry (http://www.randomhacks.net/articles/2007/04/28/bowling-in-haskell) that was picked up by dzone.com demonstrating how to keep score of a bowling game using Haskell. I modified the Haskell version to use the Maybe data type to allow scoring of incomplete games and then ported the code to Erlang and Scala to get a feel for the language feature. If anyone is interested, here is the Erlang version I came up with:

-module(bowling).
-export([tallyGame/1]).

scoreToInt(X) ->
       case X of
               none -> 0;
               _ -> X
       end.
     
take(N,L) ->
       if (N > 0) ->  
           case L of
               [X|Rest] -> [X] ++ take(N-1, Rest);
               [] -> []
           end;
           true -> []
       end.
     
reduce(F,YS) ->
       if
           (YS == []) -> [];
           true -> {X, YS2} = F(YS),
                   [X] ++ reduce(F,YS2)
       end.

invalid_pin_count() -> throw("invalid_pin_count").

scoreFrame(Balls) ->
 case Balls of
       [X|_] when X <> 10 -> invalid_pin_count();
       [_,X|_] when X <> 10 -> invalid_pin_count();
       [X1,X2|_] when X1 <> 10) -> invalid_pin_count();
       [X1,Y1,Y2|Rest] when (X1 == 10) -> {(X1+Y1+Y2), [Y1,Y2] ++ Rest};
       [X1,X2,Y1|Rest] when ((X1 + X2) == 10) -> {(X1+X2+Y1), [Y1] ++ Rest};
       [X1,X2|Rest] -> {(X1 + X2), Rest};
       _ -> {none, []}
 end.
     
scoreGame(Balls) -> take(10,reduce(fun scoreFrame/1, Balls)).

tallyScores(Accum, L) ->
       case L of
           [] -> [];
           [Head|Tail]  -> Total = (Accum + scoreToInt(Head)),
                           [Total] ++ tallyScores(Total, Tail)
       end.
     
tallyGame(L) -> tallyScores(0, scoreGame(L)).

Run this in "erl" via "bowling:tallyGame([<rolls>])". Example:

bowling:tallyGame([10,10,10,10,10,10,10,10,10,10,10,10]).
[30,60,90,120,150,180,210,240,270,300]

With some feed back from members of the Scala lounge mailing list, this is the Scala version:


object FunctionalBowling {
 type Score=Option[int]
 type Balls=List[int]

 def reduce[A,B](f:(A => (B, A)), ys:A): List[B] =
   if (ys == Nil) Nil
   else {val prime = f(ys); prime._1 :: reduce(f, prime._2)}

 def scoreGame(balls:Balls): List[Score] = reduce(&scoreFrame,balls).take(10)
 
 implicit def scoreToInt(score:Score): int = score getOrElse 0
 
 implicit def intToScore(in: int): Score = Some(in)

 def invalidPinCount() = throw(new Exception("Invalid Pin Count"))
 
 def scoreFrame(balls: Balls): (Score, Balls) = balls match {
  case (x :: _) if (x <> 10) => invalidPinCount() // Invalid first roll
  case (_ :: x :: _) if (x <> 10) => invalidPinCount() // Invalid second roll
  case (x1 :: x2 :: _) if (x1 <> 10) => invalidPinCount()
   // Total pin count for spare frame can't be > 10
  case (x1 :: x2 :: x3 :: rest) if x1 == 10 => (x1 + x2 + x3, x2 :: x3 :: rest)
  case (x1 :: x2 :: x3 :: rest) if x1 + x2 == 10 => (x1 + x2 + x3, x3 :: rest)
  case (x1 :: x2 :: x3 :: rest) => (x1 + x2, x3 :: rest)
  case (x1 :: x2 :: Nil) if x1 + x2 < 10 =""> (x1 + x2, Nil)
  case _ => (None, Nil)
 }

 def tallyScores(accum:int, x:List[Score]):List[int] = x match {
  case Nil => Nil
  case x :: rest => val total = accum + x
        total :: tallyScores(total, rest)
 }

 def main(args:Array[String]):Unit = {
  val roll_list = args.toList.map(Integer.parseInt)
  System.out.println("Scores: " + tallyScores(0,scoreGame(roll_list)));
 }
}

Invoke the Scala version via "scala FunctionalBowling <rolls separated by space>". Example:

scala FunctionalBowling 10 9 1 10 9 1 10 9  1 10 9 1 10 9 1 10 9 1
Scores: List(20, 40, 60, 80, 100, 120, 140, 160, 180, 200)