Java's drag and drop functionality is painful. What I want is a list that the user can reorder by dragging. Here a couple of nice efforts with the caveat that they work only for single selections.
Sun's tutorial is here. There's a chapter in O'Reilly's Swing Hacks about it, but their code seems buggy to me.
Classcycle is a tool for analyzing dependencies among Java classes and packages. It can really help when trying to make sure you haven't introduced any unintentional dependencies. It's similar to JDepends, but a little more up-to-date. Its output in a nicely formatted web page (actually an xml + xsl -> html deal).
There's a lot going on in the world of programming languages these days - from functional/OO crossbreeding to new language constructs for concurrency. Here's a few random interesting tidbits:
Oh yeah, and concurrency is where it's at too:
On a cold gray sunday afternoon, I went through the tutorial for the Scala programming language (by a group in Switzerland called LAMP). There was an exercise straight out of SICP about evaluating simple algebraic expressions. Here's what I came up with. It may be far from optimal, but seems to work for at least the one test case.
abstract class Tree
case class Sum(l: Tree, r: Tree) extends Tree
case class Var(n: String) extends Tree
case class Const(v: int) extends Tree
object Expressions {
type Environment = String => int
def eval(t: Tree, env: Environment): int = t match {
case Sum(l, r) => eval(l, env) + eval(r, env)
case Var(n) => env(n)
case Const(v) => v
}
def derive(t: Tree, v: String): Tree = t match {
case Sum(l, r) => Sum(derive(l, v), derive(r, v))
case Var(n) if (v == n) => Const(1)
case _ => Const(0)
}
// there's probably a more functional way to do this
def simplify(t: Tree): Tree = t match {
case Sum(l, r) =>
val sl: Tree = simplify(l)
val sr: Tree = simplify(r)
sl match {
case Const(lv) => sr match {
case Const(rv) => Const(lv + rv)
case _ =>
if (lv==0) sr
else Sum(sl,sr)
}
case _ => sr match {
case Const(rv) if (rv==0) => sl
case _ => Sum(sl,sr)
}
}
case Var(n) => Var(n)
case Const(v) => Const(v)
}
def toString(t: Tree): String = t match {
case Sum(l, r) => "(" + toString(l) + " + " +
toString(r) + ")"
case Var(n) => n
case Const(v) => v.toString()
}
def main(args: Array[String]) {
val exp: Tree = Sum(
Sum(Var("x"),Var("x")),
Sum(Const(7),Var("y")))
val env: Environment = { case "x" => 5 case "y" => 7 }
println("Expression: " + toString(exp))
println("Evaluation with x=5, y=7: " + eval(exp, env))
println("Derivative relative to x: " +
toString(derive(exp, "x")) + " = " +
toString(simplify(derive(exp, "x"))))
println("Derivative relative to y: " +
toString(derive(exp, "y")) + " = " +
toString(simplify(derive(exp, "y"))))
}
The subclasses of Tree define the nodes of a parse tree for simple expressions like:
((x + x) + (7 + y))
The program demonstrates Scala's pattern matching capabilities, defining methods that perform operations on trees: evaluate, take derivatives, and print. Pattern matching is a feature borrowed from the ML family of languages. You might think of them as case statements on steroids. Sometimes they can concisely replace polymorphism. Here, they play the role of the visitor pattern.
The visitor pattern makes it easy to add new operations on all members of an inheritance hierarchy in a modular way. (Modular meaning the operation is encapsulated). The cost is that adding a new member to the inheritance hierarchy requires modification of all existing operations. The cost and benefit of pattern matching statements is the same.
More Scala Resources:
I know there are ways to do all these things that only take a few steps, but they're fundamental tasks that deserve a one-step command. "Implement this interface" is a lot closer to how I think than "Create a class that implements interface Foo".
Posts
R Bloggers