Richard's technical notes

This blog has moved

noreply@blogger.com (Richard) — Sun, 28 Feb 2010 18:29:00 +0000

This blog has moved to http://richard.dallaway.com/ or http://richard.dallaway.com/rss.xml if want the feed URL. Sorry. Thanks.

Scala in London in 2010

noreply@blogger.com (Richard) — Fri, 29 Jan 2010 15:05:00 +0000

There's plenty of Scala and Lift events in London this year....

The London Scala User Group (which you can learn about at lsug.org) is running a free event every month of the year. Last night Miles gave an introduction to Scala for Java developers, and the slides are available as a PDF. Next month on Feb 8th, Colin is giving examples of re-writing Java classes in Scala and making your code lovely.

On 8th March I'll be doing a "Getting Started with Lift" session, which you can sign up for at the Skillsmatter site.

There's also...

a Scala day at JAX (22 Feb, with a LSUG.org pub meet after)

Martin Odersky will be giving a class in June

A Scala Lift-off event in September

...and there will probably be a London Java User Group Unconference at some point which will have a Scala element.

If you want a peek at what the other LSUG events are being planned for the year, get a Google Wave account and search for the LSUG wave, but join the London Scala User meetup.com group to be emailed the announcements.

Functional Programming Events

noreply@blogger.com (Richard) — Thu, 03 Dec 2009 13:37:00 +0000

Next week I'll be heading up to the Skillsmatter Functional Programming Exchange event (Mon 7 December 2009). I hoping to learn some good stuff there. The following day there's a BrightArray event where we're going to discuss the paper Why Functional Programming Matters.

London Java Community Unconference 1

noreply@blogger.com (Richard) — Sun, 29 Nov 2009 10:03:00 +0000

Congratulations to the organizers of the London Java Community: the first unconference was a success.

IBM kindly hosted the event at their Southbank building, and it's a great location for an unconference. It has a set of rooms that are just the right size, but also has a central mingling point where you can meet and chat with people. Possibly for the first time at a conference for me the gaps between the sessions were as useful as the sessions themselves.

I ran a session to discuss what's stopping anyone from using Scala, especially in existing Java projects. Kind of a negative title in some ways, but the point is that I don't see any technical reasons not too as the tool chain is there. I was interested to hear other's experiences. The slides from my session are online, but they were really just put up to help kick start a discussion between the 19 people who were in the room.

It tuns out there's a detailed Google Wave covering this and other sessions, but I'll list the main points that were discussed here:

Learning: there seemed to be a reluctance to use Scala until you know "the Scala way" or understand functional styles. It does seem fair to say you'll get more benefit from adopting more of Scala, but I feel that you need to at least start using Scala to understand how it can improve what you do. The point was made that you can start using Scala in a Java-like way (there's absolutely nothing wrong with that), and get some benefits today.
What are the benefits? Aside from less code, code that is easier to understand (IMHO), increased developer joy or passion, I pointed to the previous session which covered The Bug of the Month which was a hairy threading-related issue: if you're doing anything with threads, you've probably got it wrong. The actors library in Scala can simplify concurrency.
Commercial support: There's no named organization backing Scala. So where does the warm Sun, IBM, Oracle feeling come from for management?
What areas is Scala best applied to? That is, what areas of Java would you prefer to use Scala for? The honest answer is all areas. There's no place where you'd prefer Java over Scala.
Selling to management: why take the risk? I think it's a case of why miss the opportunity, if you can deliver more reliable results faster, and keep developers happy and engaged.

I suggested—and it's not an original idea—that unit testing might be a place to start as you can improve tests and gain experience. I put an example of that in my slides that I ripped out of some production code just before the presentation.

There were requests for more Scala resources (damn...perhaps I should have done an intro to Scala session too) so here are the resources I've found useful:

scala-lang.org - for downloads of Scala and a list of the published books.
http://daily-scala.blogspot.com/ - short examples of idiomatic Scala.
Scala Users mailing lis, where you can ask questions.

In the pub afterwards, there was a Scala corner where the London Scala User Group was reinvigorated. The lsug.org has been recovered and Skillsmatter have kindly offered to host a monthly event, probably on a Wednesday, starting in Jan 2010. Keep an eye on the LJC mailing list for news.

You'll find my photos of the event on Flickr and the hash tag on Twitter is #ljcuc1.

Great functional programming lectures

noreply@blogger.com (Richard) — Mon, 09 Nov 2009 11:25:00 +0000

A few weeks back Miles emailed the BrightArray group with a link to Erik Meijer's Functional Programming Fundamentals lectures. You can find them listed at channel9 tagged as C9 Lectures.

I'm not planning to use Haskell for real, but I wanted to pass the links on because I'm finding the lectures really helpful for thinking about software. Possibly for thinking in general.

Two practical points about the series: you don't have to install silverlight to watch them as there are links to other formats over on the right of the page. And the slides can be found over at Graham Hutton's Programming in Haskell page.

Oh, and don't forget to do the homework.

Nov 28: London Java Unconference

noreply@blogger.com (Richard) — Fri, 30 Oct 2009 15:46:00 +0000

On Sat Nov 28th 2009, I'll be at the London Java Community's Unconference at the IBM south bank building. Not exactly sure what I'll contribute, but my current thinking is something around the area of approaches to adding Scala into existing Java projects.

Check out the details on the Upcoming page or read more on the LJC's blog post. It's £20 to cover costs (any left-over money is put behind the bar :-), but hurry... when I last checked there were only 11 places left out of 50.

Setting the character encoding in Scala

noreply@blogger.com (Richard) — Mon, 21 Sep 2009 08:55:00 +0000

The only reliable way we've found for setting the default character encoding for Scala is to set $JAVA_OPTS before running your application:

$ JAVA_OPTS="-Dfile.encoding=utf8" scala
Welcome to Scala version 2.7.5.final [...]
Type in expressions to have them evaluated.
Type :help for more information.

scala> val x = "garçon"                                     
x: java.lang.String = garçon

Just trying to set scala -Dfile.encoding=utf8 doesn't seem to do it. Of course, you may not need this if your OS defaults to a sensible character encoding. I'm lumbered with something called "MacRoman"...

You'll also want to make sure your terminal is set to UTF-8 encoding, which on the Mac is Terminal -> Preferences -> Settings -> Advanced -> International.

The Scala REPL is great for Java developers too

noreply@blogger.com (Richard) — Thu, 17 Sep 2009 08:41:00 +0000

This post is for Java developers who have heard about Scala but, although it might sound interesting, are getting on with what they need to do in Java thankyouverymuch.

If that's you, it's still worth installing Scala because the command-line tool makes noodling with Java a delight. The tool in question is the REPL (read-eval-print-loop, a language shell).

Two quick examples...

Let's say there's some API you're going to use, but you just can't quite remember the format of the return result. The REPL is a great way to quickly find out what you actually get. Here's what I found out looking for the list of all TimeZones:

$ scala
Welcome to Scala version 2.7.5.final [...]
Type in expressions to have them evaluated.
Type :help for more information.

scala> import java.util.TimeZone
import java.util.TimeZone

scala> TimeZone.getAvailableIDs()
res2: Array[java.lang.String] = Array(Etc/GMT+12, Etc/GMT+11,
 MIT, Pacific/Apia, Pacific/Midway, Pacific/Niue, 
 Pacific/Pago_Pago, Pacific/Samoa, US/Samoa, America/Adak,  
 America/Atka, Etc/GMT+10, HST, Pacific/Fakaofo, 
 Pacific/Honolulu, Pacific/Johnston, Pacific/Rarotonga, 
 Pacific/Tahiti, SystemV/HST10, US/Aleutian, US/Hawaii,  
 Pacific/Marquesas, AST, America/Anchorage, America/Juneau, 
 A...

Most of the developers I know might do a double take at the results syntax but wouldn't have a problem reading that TimeZone.getAvailabeIDs() gives me back an array of strings like "Pacific/Tahiti". No Scala knowledge required to make use of that tool (ok, I left the line-ending semi-colons out, but you can put them in if you like).

Second example. Quick! Answer this: what does String.split return if there are no matches to the pattern? Not sure? Try it and see:

scala> "Pacific/Tahiti".split("/")
res3: Array[java.lang.String] = Array(Pacific, Tahiti)

scala> "wibble".split("/")        
res4: Array[java.lang.String] = Array(wibble)

Hope that's useful. Don't miss that you have command history editing (arrow keys on my keyboard).

If you want to do more take a look at First Steps to Scala.

Using an existing Scala + Maven project in Eclipse

noreply@blogger.com (Richard) — Thu, 23 Jul 2009 11:29:00 +0000

In case you're having problems using the Scala IDE for Eclipse with Maven projects, here's what I do:

Generate the Eclipse project files from the shell: mvn eclipse:eclipse. If you already have Eclipse .project files, you'll have to remove them first or mvn eclipse:clean.
In Eclipse, do a File -> Import... and select "General -> Existing Projects into Workspace", navigate to my maven project and select it.
This gives you a Scala project, but you'll need to enable Maven: right click on the root of the project in the Package Explorer in Eclipse, select Maven menu and enable.

The plugins I have look like this:

...and it all works very well. The Maven plugin is the m2 one.

Troubleshooting: If that doesn't work first time for you: Project -> Clean... is your friend. If you're still having problems, a Refresh and Close Project followed by an Open project is good. In the worst case, close the project, exit Eclipse, remove the .metadata folder (at your own risk), and restart.

You might also want to check out the Scala IDE for Eclipse wiki pages for how others use Maven.

And for the record, I'm using a Mac (64bit, 10.5.7), with Maven 2.2.0 configured in Eclipse preferences to be an External installation (not the Embedded, but I don't know if that makes a difference or not), JDK 1.5, using Eclipse classic 3.4.2.

The Smileys in Scala

noreply@blogger.com (Richard) — Sun, 17 May 2009 21:08:00 +0000

or: a visual interpretation of some of the syntax of the Scala programming language, with the aim of providing an aide memoire.

The Happy Walrus `: =>`

(Yeah, I needed to include the : to make this work).

"The walrus prefers shallow shelf regions and forages on the sea bottom." And like the walrus, in Scala the symbol for by name parameters allows the shallow surface parameter to forage deep inside your code.

An example from Beginning Scala of a method that keeps appending the results of a block of code until the test is true:

def bmap[T](test: => Boolean)(block: => T): List[T] = {
 val ret = new ListBuffer[T]
 while (test) ret += block
 ret.toList
}

Here we see two walruses, test and block, neither of which are evaluated as parameters until you dive into the body of the method.

The Scissors `>:`

Putting a lower bounds on a type is rather like cutting off the option of passing a subclass. That is, anything to the left of the scissors in...

def doStuff[B >: T](p: B) = ...

... is snipped away if the type to the left is a subclass ("below") the type on the right. I find it helps to mentally rotate 90 degrees anti-clockwise to see the scissors cutting B if it's "below" T in the class hierarchy.

Chapter 19 of Programming in Scala has the details, as does 8.3 of Scala By Example (PDF).

Let's wield the scissors, by considering a manager who can't handle detail: they can think about fruit and apples, but nothing more specific...

scala> case class Fruit()
defined class Fruit

scala> case class Apple() extends Fruit
defined class Apple

scala> case class Pippin() extends Apple
defined class Pippin

scala> class Manager[A >: Apple]
defined class Manager

scala> new Manager[Fruit]
res2: Manager[Fruit] = Manager@3b2000a5

scala> new Manager[Apple]
res3: Manager[Apple] = Manager@276c9124

scala> new Manager[Pippin]
:11: error: type arguments [Pippin] do not conform to class
 Manager's type parameter bounds [A >: Apple]

The Fussy Bird `<:`

When it comes to...

A <: B

...the fussy bird knows that the morsel on the left is the special, tastier class when compared to the big old lump of class to the right. In Scala it signifies an upper bound, that A must be the same or a subtype (specialism) of B. And special means tasty, so no wonder she's got her beak and eyes pointing left towards the tasty class.

scala> case class Stuff()
defined class Stuff

scala> case class Food() extends Stuff
defined class Food

scala> case class TastyFood() extends Food
defined class TastyFood

scala> def peck[A <: Food](p: A) = println("yum")
peck: [A <: Food](A)Unit

scala> peck(Food())
yum

scala> peck(TastyFood())
yum

scala> peck(Stuff())
:10: error: inferred type arguments [Stuff] do not conform
  to method peck's type parameter bounds [A <: Food]
       peck(Stuff())

The bird is so fussy she'll even be happy with Nothing.

So that's the three I've had to work to remember. I hope I've got that far enough in the direction of correct to be useful. Someone will have to sort out stories for <% (view bounds) and the rest of the syntax you might see such as /:.

Still loving the Scala

noreply@blogger.com (Richard) — Sun, 10 May 2009 18:35:00 +0000

The other night I sat down to satisfy just one more quick-fix screen-scraping twitter-based itch. Of course I decided to scratch using Scala, and it really is an attractive language for "doing stuff". It also made me reflect on how Scala has already started to changed the way I write software.

Here's the itch: If you live in the centre of the pebble-beach city of Brighton, and have a dog, the tide times become really interesting, because at low tide sand is revealed, and sand is fantastic to play fetch in. You can get Brighton tide times from VisitBrighton.com, but of course I want the information at the point I'm going to use it. And for me, that means I want a tweet at 6:30 every morning. And so, @brightontide was born (I'm still chatting about copyright with the council, so it might have to disappear).

The problem could be boiled down to curl -> grep/sed/awk -> curl, but there's the added complication that tide times are in GMT, and I want to tweet them corrected for daylight saving.

So with that background out of the way, here we go...

In essence I want to get the tide times for a given date:

trait TideSource { 
 def lowsFor(day:LocalDate): List[Tide]
}

I'm using the Joda Time classes LocaDate and LocalTime to represent a date (without time) and a time (without a date). The Tide class is just a wrapper for the time and height of the tide, plus the method for converting the time into the right timezone:

case class Tide(when:LocalTime, height:Metre) {
  
 override val toString = when.toString("HH:mm") + 
   " (" + height + ")"   

 def forZone(destZone:DateTimeZone) = 
   Tide( when.toDateTimeToday(DateTimeZone.forID("GMT")).
    withZone(destZone).toLocalTime(), height)  
}

Next I need to implement a TideSource and, until I find something less hacky, that will be an implementation that scrapes the data from VisitBrighton.com. I want to use it like this:

val tide_times = VisitBrightonScraper.lowsFor(today)

Here's the code to allow that:

object VisitBrightonScraper extends VisitBrightonScraper 

class VisitBrightonScraper extends TideSource {

 def page = Source.fromURL(
  "http://www.visitbrighton.com/site/tourist-information/tide-timetables").mkString

 override def lowsFor(day:LocalDate) = {
    
  // We want the times that start with the date in this
  // format: 10th May 2009
  val date = day.ordinal + 
   DateTimeFormat.forPattern(" MMM yyyy").print(day); 
  
  val Pattern = 
   """|(?sm).*<div class="TidalDataEntry"><h3>DATE</h3><table class="TidalData"><tr>
       |<th> </th><th class="Time">Time</th><th class="Height">Height .m.</th></tr><tr>
       |<td class="Tide">High</td><td class="Time">(.+?)</td><td class="Height">(.+?)</td></tr><tr>
       |<td class="Tide">Low</td><td class="Time">(.+?)</td><td class="Height">(.+?)</td></tr>
       |</table></div>.*""".stripMargin
          .replaceAll("\n","").replaceFirst("DATE", date).r

  try  {
   val Pattern(high_times,high_heights,low_times,low_heights) = page

   // The times and heights are in separate columns;
   // multiple values separated by "<br/>"
   val tides = for ( (time_string,height) <- 
    low_times.split("<br/>") zip low_heights.split("<br/>") )
    yield 
     Tide( time_string.toLocalTime, Metre(height.toDouble) )

   tides.toList
  }
  catch {
   case x:scala.MatchError => println(x)
   Nil 
  } 
}

(Yuck. I have to find a better way to format code on this blog)

There's nothing particularly exciting in any of this, but there are a couple of things that surprised me. The first is the zip function, which I distinctly remember reading about and thinking at the time: "nice, but there's no practical application I'll write that will ever need that" :-) But here we are, with a page layout where I have two columns of numbers that need to be paired up: exactly what zip does, and it saved me a couple of loops.

The regular expression is a bit hairy. You can figure out what's going on if you view the source of the page:

But that code is going to need a unit test. But how to "mock out" the HTTP request? In Java, I probably would have separated things more so I supply the content of the HTTP request to another method that processes it. Or maybe I'd have a factory to supply something that can fetch the HTML; or perhaps I'd use dependency injection.... but this is a quick script, to do a hacky job... but I do want to test it. It turned out to be so very easy:

object MockScraper extends VisitBrightonScraper {
 override def page = Source.fromFile(
  "src/test/resources/visitbrighton07052009.html", 
  "UTF-8").mkString
}

Nothing you can't do in Java, but here it feels so concise and easy that it something that becomes usable for a unit test.

Here's the corresponding test code that uses this test scraper:

object VisitBrightonScraperSpec extends Specification {

 "Visit Brighton screen scraper" should {
     
  "locate low tide in first day" in { 
   
   val tides = MockScraper.lowsFor(new LocalDate(2009, 5, 7))
   tides.length must be_==(2)

   val expected = List( Tide(new LocalTime(3,38), Metre(1.0)), 
    Tide(new LocalTime(15,59), Metre(1.0)) )
      
   tides must be_==(expected)
 }
 // etc
}

Putting it together, you get:

object TideTweet {

 def main(args:Array[String]) {

  val today = new LocalDate

  // Time tides are in GMT, but we will later convert to
  // whatever timezone we're in:
  val tz = DateTimeZone.getDefault
     
  val gmt_tides = VisitBrightonScraper.lowsFor(today) 
     
  val tweet = gmt_tides match {
   case Nil => "Gah! Failed to find tide times today.... Help!"
   case tides => today.toString("'Low tides for 'EE d MMM': '") +
    tides.map(_.forZone(tz)).mkString(", ")
  }

  println(tweet)
     
  if (args contains "-dotweet")
   send(tweet)
     
}

I've skipped some of the details: you can download a tar.gz of the source if you're interested.

This isn't exactly great code (error states returning Nil? Twitter passwords baked into the source?) but it was an absolute joy and pleasure to write it in Scala.

Scala & Wicket London Meet Up

noreply@blogger.com (Richard) — Thu, 05 Feb 2009 20:09:00 +0000

I know next to nothing about the Wicket web framework, but I was intrigued by the jWeekend London Wicket User's Group meet up last night. The topic was "Scala and Wicket".

As far as Scala and web frameworks go, the main name is Lift. The problem with Lift... No, let me re-phrase that because it's not a problem with Lift. The great thing about Lift is that it's made for Scala, so it's going a great fit to the language. Learning Lift and Scala at the same time should mean you're bouncing the framework learning and the language learning off each other, which is going to teach you a lot.

Then again... if you're learning the language and trying to get your head around a framework, it seems to make the goal of "doing something useful with Scala" just that little bit further away. So how about this: Scala and Java work well together, so why not use a web framework you already know, but just use Scala instead of Java? Start gently, then, when ready, take a look a Lift.

I don't know which approach is best, but it seems there might be something in the gently-gently approach. There is one other compelling reason for looking at a existing (legacy? :-) web framework: you can dig into the publications on the topic, such as Wicket in Action, or Programming Struts, or Stripes etc. (Obviously this situation will change for Lift: I've already expressed my disappointment that none of the big publishers are looking at the practical aspects of Scala, but there is the start of a creative commons text).

Sure, you're not necessarily going to learn Scala idioms from a non-Scala framework, and you're going to run into head-scratching issues, but it seems somehow more manageable to at least try it. More so if you're inserting Scala into an existing project.

Of course, the whole argument falls apart for me in the case of this event, as I don't know Wicket :-) But I've tried Scala in a trivial way with a large existing Struts 1 application, and it was surprisingly painless.

But back to the event and the talks:

Daan van Etten gave a lovely "Basic Introduction to Scala With Wicket". The slides, handouts and code are available. One download and two commands to get the example app up and running was pleasing.
Dean Phersson-Chapman spoke about his "Experiences Converting an Existing Wicket Application To Scala". It seems there are some serialization issues between Wicket and Scala 2.7.3 which are being fixed.
Jan Kriesten showed examples of "Real World Scala and Wicket". If you'd not seen Scala before, this was probably pretty scary stuff in places. Jan clearly knows his Scala and his Wicket very well.
Finally, Alastair Maw spoke about the evils of abstraction, which had some fine points about when to avoid it (mostly) and when to embrace it (rarely).

It looks like slides appear over at londonwicket.org.

Four Scala Books

noreply@blogger.com (Richard) — Thu, 22 Jan 2009 13:01:00 +0000

In addition to the completed and shipping Programming in Scala book from Artima, there are three others in the works:

Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine from Pragmatic Programmers
Programming Scala from O'Reilly
Beginning Scala from APress.

Great news.

If I'm going to be picky, I'd say I'm a little concerned all these look like they are language books, rather than "activity books". What I mean by that is there's no "Database Persistence using Scala" or "Building Fast Web Sites Quickly with Scala" or "Asynchronous Messaging with Scala"... you get the idea. Sure, you can just get on and use the Java way, but the idiomatic Scala approach is what I'm looking for.

The 'Hull City Problem' in Scala

noreply@blogger.com (Richard) — Wed, 14 Jan 2009 20:32:00 +0000

Now that I have a physical copy of Programming in Scala next to me, the final excuse for me not spending more time with the language has gone. In the interest of dipping my toe in the language (well, it's more like my whole leg by now) I'm making a conscious effort to do all and any scripty things I have to do in Scala.

One such script-like thing is the 'Hull City problem'. It's actually a very simple problem, and now I think about it, it's more an assertion than a problem: Hull City football club is the only club name in the English league that cannot be coloured in.

By which I mean, if you look at a name like "Liverpool", it is made up of letters that are fully enclosed. If you were doodling you could colour in the "o"s, the "p"s and the top of the "e". You can't do that with "Hull City". Not in title case, not in upper case and not in lower case. There's no other club in the league that you can say that about.

Or can you?

Clubs come and go, and even change name, so it'd be handy to have a script that could test that the assertion is still true. Here's how I went about it in Scala, once I'd decided it was partly a regular expression problem. Yes, regular expressions are my hammer of choice.

Although not really necessary for this problem, I defined a class for the name of the club and the level in the league (e.g., 1 is the Premier League; 12 is Gloucester Northern Senior League), and a method for deciding if the name can be coloured in:

class Club(val name:String, val level:Int) 
{
 val failChars = "&ABDOPQRabdegopq"
  
 // We're given team names in Title Case, so that's what we 
 // check here. The name can be coloured in if there exists 
 // a character in the name that is contained in the list 
 // of "fail characters". 
 def canBeColouredIn = name.exists(c => failChars.contains(c))   
}

That seems OK:

$ scalac Club.scala 
$ scala
Welcome to Scala version 2.7.2.final [...]
Type in expressions to have them evaluated.
Type :help for more information.

scala> val hull = new Club("Hull City", 1)
hull: Club = Club@bc9065

scala> hull.canBeColouredIn
res0: Boolean = false

scala> new Club("Liverpool", 1).canBeColouredIn
res1: Boolean = true

To try this on all clubs you need to export the list of teams from Wikipedia, which gives you an XML file that contains a list of club names in a Wiki markup text format. A line in that file looks like this: |[[Aveley F.C.|Aveley]]||[[Isthmian League]] [[Isthmian League Division One North|Division One North]] (Level 8)

And you also need some code to read the file and run a regular expression over it:

import scala.io.Source
object Club 
{
 def load(filename: String): Iterator[Club] =
 {
  // Helper to remove the crud from team names:
  def clean(input:String) = input.replaceAll("&","&").
              replaceAll("AFC","").replaceAll("A.F.C.","").
              replaceAll("F.C.","").trim

  val fileContents = Source.fromFile(filename, "UTF8").mkString
     
  // Regular expression for extracting team name and level. 
  val clubInfo = """\|\[\[([^|\]]+).*\(Level (\d+)\)""".r 
    
  for(clubInfo(name,level) <- clubInfo findAllIn fileContents)
    yield new Club(clean(name),level.toInt)
 }
}

A couple of points here: reading a file into memory using Source and mkString is rather handy compared to what I'd usually do (i.e, using a buffer and a loop, or grabbing a library that has it defined already); creating a regular expression means calling .r() on a String which is almost as short as having regular expressions as part of the syntax of the language. But I think it's the for loop that stands out. The findAllIn call looks straight-forward enough, but the left hand side of that is cute. A regular expression in Scala, such as clubInfo, is also an "extractor" in the language, which for me is probably best explained by example as I don't have a full grip on all the concepts yet:

$ scala
Welcome to Scala version 2.7.2.final [...]
Type in expressions to have them evaluated.
Type :help for more information.

scala> val clubInfo = """\|\[\[([^|\]]+).*\(Level (\d+)\)""".r 
clubInfo: scala.util.matching.Regex = \|\[\[([^|\]]+).*\(Level (\d+)\)

scala> val clubInfo(name,level) = "|[[Aveley F.C.|Aveley]]||[[Isthmian League]] [[Isthmian League Division One North|Division One North]] (Level 8)"
name: String = Aveley F.C.
level: String = 8

scala> println(name)
Aveley F.C.

scala> println(level)
8

Handy? I think so. Especially when you can use it in a for loop to split out the matches into the two groups.

Putting it all together (and you can download the source files if you want) we can print out all the clubs that cannot be coloured in:

$ scalac Club.scala 
$ scala
Welcome to Scala version 2.7.2.final [...]
Type in expressions to have them evaluated.
Type :help for more information.

scala> val clubs = Club.load("footballclubs.xml")
clubs: Iterator[Club] = non-empty iterator

scala> for(club <- clubs; if !club.canBeColouredIn)
     | println(club.name)
Hull City

So there we have it. It's true: only Hull City can not be coloured in. For now...

UPDATE: If you prefer just the script version, here it is condensed:

def clean(input:String) = input.replaceAll("A.F.C.","").trim

def isGood(name:String) = 
   !name.exists( c => "&ABDOPQRabdegopq".contains(c) )

val regexp = """\|\[\[([^|\]]+).*Level""".r 

import scala.io.Source

for( line <- Source.fromFile("footballclubs.xml", "UTF8").getLines; 
     regexp(name) <- regexp findAllIn line; 
     if isGood(clean(name)) )
  println(name)

Augmented Reality at £5 App Xmas Special

noreply@blogger.com (Richard) — Wed, 10 Dec 2008 23:11:00 +0000

There's something right about £5 App running a demo/game/fun event as the Xmas special. I mean, how does this sound: I turn up at The Werks, icy cold, to be handed a lovely hot mulled wine by the Ribots, directed towards the mince pies, and then entertained with a range of funky technology stuff. Mmm.

This evening there were talks and demos covering: collaborative interactive fiction (a.k.a., group-generated text adventure), namely Spaceship; Emily demoing robot sumo; mobile phone Lightsaber dueling (no, not with the iPhone); eye controlled Pong, from Ben Rubinstein. All excellent.

Maybe it's because of the fun we had the previous day at the Flash Big Screen Bonanza, or perhaps it's because I'd been noodling with JavaFX, but I found Seb's Flash 3D and augmented reality demos great fun.

I'd say, of the evening, the biggest wow! was when Seb showed us the augmented reality stuff; and the biggest round of applause of the night was when he said "hey, all I've done is download it and compile it" :-)

But you don't even need to do that. From that last link, if you print out the PDF symbol, click the start button (and right click and select "USB camera" in settings, but you may not have to do that), and hold up the symbol you can try it yourself. It's not bad, eh?

The underlying tech seems to be from the C ARToolKit, which is available under the GPL and other licenses. Given that the documentation touches on support for SGI/Irix and VRML I think it must have a pretty robust history.

There's some mention of a Java bindings for it, but after a bit of digging it turns out there's a pure Java 6 port, and from what I can understand a version from the same author for the Android platform. I've not tried them; I've no idea if they work.

If you're interested in this area, there's documentation on how ARToolKit works.

Brighton Scala User Group

noreply@blogger.com (Richard) — Thu, 13 Nov 2008 12:52:00 +0000

Last night was the Brighton Scala User Group pub meet up. For the record the conversation covered:

The Scala Plugin for Eclipse, how it runs on the Mac, how it lives with Maven.
The power of Aspect Orientated Programming for fixing other people's code.
NIO.
The JVM language summit, and photos taken.
Neil Gafter, Closures In Java, what we think NG thinks of Scala.
Refinements, a.k.a. duck typing (see section 3.2.7 and specifically example 3.2.4 on page 22 of the Language Spec).
Invoke dynamic, tail recursion, catching multiple exceptions.
Is there a JSR for Java 7?
Java 7, do we care about Java language features now? We do care about the JVM.
Languages on the JVM with parity performance with Java: Scala, Clojure.
Idioms.
Mac keyboards as a way for Apple to lock in users.
What Scala language features Java developers like.
Using existing web frameworks other than Lift with Scala.
Focal length, depth of field.
Sun's war chest.
The Groovy/Grails/Spring Source deal.
Return early v. one and only one return.
Language features for nicely dealing with instanceOf tests.
Interesting corner-cases of the type system.
What *is* it about Scala that's so attractive? What problems is Scala solving?

The next event will be 17 December 2008.

FOWA 2008 London

noreply@blogger.com (Richard) — Mon, 13 Oct 2008 13:10:00 +0000

This year the London Future of Web Apps conference was held at the ExCel centre. Ah, the ExCel: a place that feels both sterile and grimy—something I thought only possible at airports and large shopping centres.

The conference? It lacked substance, and was disappointing in that respect. Still, that's not what it's all about: it's good to just take some time away from the keyboard, and talk to people about "stuff".

I did enjoy...

Matt Biddulph talking about "Dopplr: It's made of messages". A good reminder that scale out is a lot easier if from day one you plan for N > 1. I.e,. more than one web server, more than one database, etc. I was interested to see that Dopplr use ActiveMQ for messaging; and we were pointed at Enterprise Integration Patterns as a book worth reading.
Blaine Cook & Joe Stump on "Languages don't scale". A nice set up by insulting pretty much all programming languages, and then saying that of course, it's not about the language, it's about I/O and the architecture of scalability.
Blaine Cook's second presentation was on "Using Jabber to make awesome web sites". In essence: polling sucks, use PubSub instead, and in particular use the Jabber protocols to make things scale. Well, it doesn't solve all the problems, but I think the audience by now had taken the hint that messaging is useful.
I enjoyed the TechCrunch Pitch! event, in which five start ups pitched their ideas, Dragon's Den style. Except without any money being involved. And related to that (in my mind) on the following day was "Work/life balance or Blood, sweat and tears: Which is the startup way?". This was Tom Nixon arguing for some sense of work/life balance, while '80s throwback Jason Calacanis gave the other side of the argument. He didn't actually use the phrase "greed is good", but it was in the air. I liked that session; it was strangely energizing.

Those were the highlights for me. You can watch the presentations online.

Tracking down threading issues

noreply@blogger.com (Richard) — Tue, 30 Sep 2008 12:46:00 +0000

One of the projects we've been working on involves kicking off a number of threads to check on availability of certain services. Despite having read the fantastic Java Concurrency in Practice book (which you should buy, possibly from Amazon UK) we'd run into a situation where Tomcat wasn't shutting down. Inevitably it'd be because we'd starting a thread that wasn't stopping. As a reminder to myself here are a bunch of useful tools for figuring out what might be going on....

Step 1: find out what's running with jps -lm:

$ jps -lm
org.apache.catalina.startup.Bootstrap start
sun.tools.jps.Jps -lm
com.j_spaces.core.client.SpaceFinder /./taykt


This is a list of the Java process IDs which are "typically, but not necessarily, the operating system's process identifier for the JVM process", according to the JPS manual page. In my case, they were the OS process IDs, although I should point out that I'm running this on Mac OS 10.5 using JDK 5, and the tools do vary by operating system.

What the list is showing me is that the Tomcat process is still running (process 1001). All the other processes I expect to see on my machine, including the mysterious 176 which happens to be IntelliJ.

Step 2: take a look at what threads are running in the process, as described in the J2SE 5.0 Trouble-Shooting and Diagnostic Guide PDF:

$ kill -QUIT 1001

Hmm. No output from that command... of course, because I've signalled to the Tomcat process to give me a thread dump the output will be in the Tomcat logs:

==> catalina.out <==
Full thread dump Java HotSpot(TM) Client VM (1.5.0_16-133 
mixed mode, sharing):

"DestroyJavaVM" prio=5 tid=0x010017f0 nid=0xb0801000 waiting 
 on condition [0x00000000..0xb0800060]

"SelfCleaningTable$Cleaner" daemon prio=5 tid=0x01049030 
 nid=0x8e7a00 in Object.wait() [0xb171f000..0xb171fd90]
 at java.lang.Object.wait(Native Method)
 - waiting on <0x25f696f8> (a java.lang.ref.ReferenceQueue$Lock)
 at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:120)
 - locked <0x25f696f8> (a java.lang.ref.ReferenceQueue$Lock)
 at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:136)
 at com.j_spaces.obf.eb.run(SourceFile:231)

"pool-1-thread-1" prio=5 tid=0x01021470 nid=0x8f0c00 waiting
  on condition [0xb0c8a000..0xb0c8ad90]
 at sun.misc.Unsafe.park(Native Method)
 at java.util.concurrent.locks.LockSupport
   .park(LockSupport.java:118)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer$
   ConditionObject.await(AbstractQueuedSynchronizer.java:1841)
 at java.util.concurrent.LinkedBlockingQueue
   .take(LinkedBlockingQueue.java:359)
 at java.util.concurrent.ThreadPoolExecutor
   .getTask(ThreadPoolExecutor.java:470)
 at java.util.concurrent.ThreadPoolExecutor$Worker
   .run(ThreadPoolExecutor.java:674)
 at java.lang.Thread.run(Thread.java:613)
...

...it goes on for a bit. The parts I was interested in were non-daemon processes (because daemon ones are shutdown when the JVM shutsdown). In my case, the "pool-1-thread-1" process reminded me that we'd put a few things into an Executor and possibly not cleaned up properly. I know it was that thread name, because I'd seen it in the application log files. A quick dip into Java Concurrency in Practice to remind myself about The Rules, and I had a few modifications that resolved the issue. But...

Step 3: try out JConsole. The trick here is that you need to set a flag at Tomcat start up time:

$ export CATALINA_OPTS="-Dcom.sun.management.jmxremote"
$ sh startup.sh

Then a quick jps -lm to find the process number, then fire up JConsole with jconsole pid goes here and you're set. Not only do you get easier access to the thread list, you also have buttons in the MBean tab with tempting names.

GGUG Meeting

noreply@blogger.com (Richard) — Tue, 05 Aug 2008 11:58:00 +0000

I have a love/hate relationship with Groovy. I do find it wonderfully productive for hammering out a quick script to do something, but I feel uneasy attempting anything larger without my crutches of static analysis (strict shouty compilers and Find Bugs) and knowing there are great profilers if I need them. Yet, when returning to Java I'm left thinking "why do I have to write so much code?".

You'll understand, then, why I find Scala so appealing.

Still, I do use Groovy, and mostly I use Groovy in the context of Grails, where I enter small snippets of Groovy to get the job done. Even here, though, I rely on an IDE to help and the only really usable one is IntelliJ where they have done a great job on supporting Grails. Having said that, the Grails Podcast have mentioned that there's been some good Grails work in Netbeans 6.5. Don't get me wrong: Netbeans is a great tool, but in some respects it always seems to be "jam tomorrow"....

To keep up-to-date with the Grails world, I headed up to the Skillsmatter for the Groovy and Grails User Group Meeting. It was good to see who's using Grails and how people are using Grails, to chat with them at the pub, but also it was handy to hear Graeme Rocher give a "state of grails" talk. And there's some great stuff in the pipeline for 1.1:

plugins are going to be installed once on your machine and only the meta data will be written to your project, and the plugin system will resolve dependencies for you;
the plugin system is going to be faster at finding and listing plugins;
plugins can be scoped (e.g., this plugin just for testing, not deployment);
improved Maven support (the Grails POMs have been published already, I believe);
decoupling of components out of Grails, including GORM and GSP;
better Java integration, such as for JPA, JSP, portlets; and
OSGi support after 1.1.

And I suspect there will be hundreds of smaller changes too. All this is schedule for Dec 08/ Jan 09, which is the same timeframe as the two new Grails books: Grails in Action and the 2nd edition of The Definitive Guide to Grails (I would not recommend buying the 1st edition now, as it was based on Grails 0.3). As I'm mentioning books I'll just say that I found Programming Groovy: Dynamic Productivity for the Java Developer to be pretty useful.

The event was recorded, and it looks like it will appear on the Skillsmatter Java podcast page.

Scala London Coding Dojo

noreply@blogger.com (Richard) — Wed, 23 Jul 2008 06:06:00 +0000

Monday was the first Scala London User Group meeting that was held around a keyboard. Robert Rees arranged for a room, food, and drink at ThoughtWorks, Jamie Webb kindly gave an intro to Scala talk, and Aaron Roth provided print outs of a Scala for Java Programmers cheat sheet...and so we spent time working on the supermarket problem.

I counted 19 people (of which 3 were Brighton based), of mixed abilty (from functional people or Java people who had never touched Scala, all the way to expert Scala-heads), and we had working, unit tested, software by 10pm. Which—given that coding dojos sound a bit mad—is pretty good going.

Dojos are probably not going to be the way forward for this group, but I think it did a good job as an ice-breaker: an inclusive activity; a task that's not daunting, that anyone can have a crack at. I definitely learnt stuff: testing using Specs, and need to understand the Scala patterns, such as Cake for dependency injection, and I have to stop putting off looking at Lift. Perhaps the most important thing for me was to learn that the Eclipse Scala plugin is going to be able to do mixed compilation of Java and Scala source in a project.

There was video of Jamies talk. I'll add a link if it's posted any place. At the moment there's no web site for lsug but get in touch if you'd like the mailing list email address.

There are more photos on Flickr tagged with lsug.

Comparing closures in Java, Groovy and Scala

noreply@blogger.com (Richard) — Sat, 14 Jun 2008 10:09:00 +0000

On Paul's return from JavaOne this year, we spoke about Neal Gafter's Closures Cookbook talk. From what I understood, this was a look at the BGGA closures proposal, and contained an example that pushed hard on some of the tougher closure issues for Java. I thought it might be fun to look at the Java example from the talk, and covert it to Scala and Groovy.

Why those languages? Because they are the three JVM languages I'm most interested in. I suppose I could also have compared the closure support in Jython, JRuby or... well, there are a few to choose from, but this blog is going to be plenty long enough with just three.

Let's start with the Java example that was given, remembering that this is a proposed syntax, that may or may not make it to Java 7 or later. As I understood the example it was this: imagine you want to add the ability to time a block of code, and you wanted to do it in a way that would look almost like a new keyword has been added to the language; and you wanted to pass in a parameter to name what you were timing; and the block you're timing returns a result, or might throw an exception. So, quite an involved case.

Here's how the current Java proposal looks:

// Here's a method that uses the time call:
int f() throws MyException { 
  time("opName", {=> 
    // some statements that can throw MyException 
  }); 
  time("opName", {=> 
    return ...compute result...; 
  }); 
}

So we're timing a couple of operations, and we're doing this inside a method, f, that returns an integer. The implementation would be....

interface Block { 
  R execute() throws X; 
} 

public  R time( 
    String opName, Block block) throws X { 
  long startTime = System.nanoTime(); 
  boolean success = true; 
  try { 
    return block.execute(); 
  } catch (final Throwable ex) { 
    success = false; 
    throw ex; 
  } finally { 
    recordTiming( 
      "opName", System.nanoTime() - startTime, success); 
  } 
}

As you can see, time takes an arbitrary text label and a block of code, runs the block and tells you how long the block took to run and if it succeeded or not.

That's the example that was given at JavaOne. Now for the same thing in Groovy...

To make runnable code for Groovy (and for Scala), I had to decided to time something. So I'm timing a block of code that randomly throws an exception or returns something. And then timing a block of code that just returns a number. In Groovy that would be:

def time(opname, block)
{ 
 long start_time = System.nanoTime()
 boolean success = true
 try {
  return block()
 } catch (Throwable ex) {
  success = false;
  throw ex
 } finally {
  diff = System.nanoTime() - start_time
  println "$opname $diff $success"
 }
}

int f() throws Exception {
 time("a") { 
  Random r = new Random()
  if (r.nextInt(100) > 50)
   throw new IOException("Boom")
  else
   return 42
  }
 
 time("b") {
  return 7
 }
}

println f()

An example of running the code:

$ groovy time.groovy 
a 37116000 true
b 69000 true
7

$ groovy time.groovy 
a 39998000 false
Caught: java.io.IOException: Boom
 at time$_f_closure1.doCall(time.groovy:21)
 at time$_f_closure1.doCall(time.groovy)
 at time.time(time.groovy:6)
 at time.f(time.groovy:18)
 at time.run(time.groovy:31)
 at time.main(time.groovy)

Note that the Java example is typed in that it uses a generic type, R, for the return value which gives you some compile-time checks. That is, when you run time and use the result, the compiler will enforce that your declaration of the result has the same type as the return type of the block you're timing.

Although Groovy does support generics, I've not used them here, and as a result the Groovy example doesn't have that type-safety. I think that's the way one would typically write Groovy code.

UPDATE: as was pointed out to me in the comments on the Java Lobby version of this blog post, this isn't the same as the Java version. In the Java version a return in the closure returns out of the enclosing block.

Now a look at the same code in Scala:

def time[R](opname: String)(block: => R) = {
 val start_time = System.nanoTime()
 var success = true
 try {
  block
 } catch {
  case ex: Throwable => {
   success = false;
   throw ex
   }
 } finally {
  val diff = System.nanoTime() - start_time
  println(opname + " " + diff + " "+success)
 }
}

def f():Integer = {

 val answer = time("a") {
  val r = new Random()
  if (r.nextInt(100) > 50)
   throw new java.io.IOException("Boom")
  else
       "42" 
 }

 println ("the answer, "+answer+" is of type "+
      answer.getClass())

 val seven:Integer = time("b") {
  7
 }
 
 println ("seven is of type "+seven.getClass())
 
 return seven 
}

f()

I'm still not using Scala day-to-day, so this might be a little awkward: thank you to the London Scala User Group for helping me clean up my syntax, but all the mistakes are mine.

This code has the same properties as the Java code (type safety via the R generic type), but seems a little shorter and neater. Additionally, the thing I like about the Scala code (and the Groovy code) is that the languages return the value of the last statement in a block, and that the syntax allows a clean time("thing") { ... } format.

One observation: I've used the Integer class, which is deprecated, in order to be able to print out the class of the return type in the function f(). Without the :Integer declaration I was getting weird compile errors. As I said, my understanding of Scala and type inference isn't there yet.

The output from running the code:

a 913000 true
the answer, 42 is of type class java.lang.String
b 13000 true
seven is of type class java.lang.Integer

a 936000 false
java.io.IOException: Boom
 at Main$$anonfun$1.apply((virtual file):26)
 at Main$$anonfun$1.apply((virtual file):23)
 at Main$.time$1((virtual file):8)
 at Main$.f$1((virtual file):23)
 at Main$.main((virtual file):44)
 at Main.main((virtual file))
// rest of stack trace removed

There's no conclusions here. It's just an exercise in comparing closures code in three different languages. I've probably missed some of the nuances of the Java example, but hey... it's a starting point.

Mobile Monday: Monetisation through Advertising

noreply@blogger.com (Richard) — Tue, 13 May 2008 08:34:00 +0000

Last night I was at Mobile Monday London to catch four presentations. The topic: advertising on mobile. The summary: there's a need for better measurement.

Claire Valoti from Mindshare was up first, giving the agency view of mobile advertising. She split the appeal of mobile in a media plan in to two parts: as a delivery mechanic (to extended reach, getting to a winder audience in a different mode); and as a platform (for couponing, or video uploads). She then went on to describe some issues and themes... and standardization and measurement were pretty much top of the list. That is, there's currently no good standard measure of reach, sessions, traffic or users for mobile advertising. And even if there was, it needs to be integrated into existing web buying systems, rather than via a mobile-specific system.

Claire had a good observation on social networking, and the importance for mobile. The m:metrics numbers quoted showed that the 18-24 and 25-34 age groups were more likely to be using social networking from the mobile, compared to 13-17 age group. It's not just about a youth market.

Another good point was made that events drive handset usage, as does "the right handset". An example given: at the end of the football (soccer) season, there's a drop in usage; during the season people are out and about and will use the mobile internet to look up news. As for "the right device", just look at the figures for internet usage on the iPhone compared to anything else....

Obviously mobile advertising has to be used in the context of the whole campaign, and it has to be relevant content: don't go taking an ad made for TV and slapping it on a mobile. Use the right techniques to get reach (banners, SMS, bluetooth), use location information to make it relevant, use coupons and free content to make it useful to the customer. And the user experience needs to be more streamlined: don't issue mobile coupons without telling your retail staff how to handle them.

Aside from measurement, another barrier to growing advertising budgets is the number of people involved in setting up a mobile campaign. The buying experience needs to be more streamlined.

Mobile advertising challenges were summarized as: speed, reach, cost, ROI, standards, and measurement. As examples of reach issues: Claire was interested in QR codes, but only 10% of mobile devices have a reader installed; buying from Blyk or similar to get an audience was described as having "limited reach" at the moment; mobile search needs to scale up as, right now, it's hard to spend the budget.

Shan Henderson from Vodafone kicked off his presentation by saying that it's the metrics that matter. Click rate is not the full story, but it's often the headline. Also audience demographic, behaviour, session length, frequency and reach are all important because "money follows measurement in media". He showed the "measurement gap" graph. I'm sure the slides will be available soon, but for now I've done a shaky recreation:

(I'm guessing Edward Tufte would not approve). So, we all agree it seems: we need better standards for measurement and more efficency in the buying and selling of advertising in order for the market to grow.

To address this, Shan went on to describe the GSMA Metrics Study which aims to make it easy to plan and measure mobile media. Later this year it's going to produce (one or more of): guidelines, best practices, definitions, technical standards, responsible ad practices, content standards. This will all be via an as yet unnamed ABC-like trusted independent organization.

Russell Buckley took the stage to talk about Admob, a self-serve and full-service ad network, shifting 2.bn ads a month, in 160 countries via 3000 mobile web sites. They select mobile sites, put ads on them, and share the revenue with the site. He described mobile advertising as good for: bands; to promote mobile websites; for operators to monetize their sites; and content owners to have access to a new marketing channel.

There was then a page of logos of who's advertising, and it showed that the US is generally ahead in terms of adopting mobile advertising. In fact, ad requests by country (to March) showed 47% of ads were for the USA. Other figures were: India (9.8%); UK (6.7%); South Africa (5.3%); Indonesia (4.7%); Romania (1.9%); Canada (1.3%); Philippines (1.3%); France (1%); Israel (1%); RoW (20.1%). By handset, Nokia were the top, although they are dropping: something that's not yet reflected in their market share.

Russell presented some case studies. MTV wanted to drive traffic to an awards site, and using text adverts they had a 300% traffic boost and 400% increase in downloads. Land Rover USA saw 23% of users interacting with an advertised landing page, with 3% going on to click the link to make a call to a dealer. Adidas saw a CTR of "well above 3%". Coca-Cola saw a CTR of 1.31%, but 130% watched a mobile video that was being promoted (some people watched it more than once).

Ray Anderson from Bango described the basic model for using advertising as: select a channel, measure response, look at user purchases, analyse ROI, then... repeat.

He made some great observations on the issues of search. Depending on the combinations of search provider and operator, you may find you get very different results from the advertising spend (especially if the content is transcoded). But he had a graph that compared the revenue Bango customers had received over time from Orange and Vodafone: the doubling (or more) in the graphs when the operators introduced a search page was impressive.

After the talks there was a brief panel session. All good stuff. And held in a great building.

Photos: from Route79, from appelquist, from Alex Craxton

Video and audio: usual appear on the Mobile Monday web site after a little while, so check there.

Decrypting JetS3t Files

noreply@blogger.com (Richard) — Sun, 13 Apr 2008 11:48:00 +0000

This post is going to be a bit niche. The scenario is that you've used JetS3t to backup data to Amazon S3 via the synchronize tool, and in particular you've used the -c option to encrypt the data. But you've downloaded the file with another tool, such as ForkLift or S3 Browser. How do you decrypt the downloaded file?

The default encryption is PBEWithMD5AndDES, and with that knowledge you may be able to find a tool that can decrypt it for you. I went a different way, and just hooked straight into the encryption utilities inside JetS3t:

// Apache 2 license 
public static void main(final String... args) 
    throws GeneralSecurityException, IOException
    {
      
        if (args.length != 4 && args.length != 2)
        {
            System.err.println(
              "Usage: Decrypt [-alg algorithm] KEY FILE");
            System.exit(1);
        }
   
        final String alg;
        final String key;
        final File encryptedFile;
        
        if (args.length == 4)
        {
            alg = args[1];
            key = args[2];
            encryptedFile = new File(args[3]);
        }
        else // use defaults for algorithm:
        {
            alg = "PBEWithMD5AndDES";
            key = args[0];
            encryptedFile = new File(args[1]);
        }
        
        final EncryptionUtil eu = new EncryptionUtil(
                key, alg, EncryptionUtil.DEFAULT_VERSION);
        
        CipherInputStream decrypt=null;
        BufferedOutputStream outStream=null;
        try
        {
            decrypt = eu.decrypt(
                 new FileInputStream(encryptedFile));
            IOUtils.copy(decrypt, System.out);
        }
        finally
        {
            IOUtils.closeQuietly(decrypt);
            IOUtils.closeQuietly(System.out);
        }
               
    }

So with a bit of fiddling you can copy, paste and compile that (you'll need the JetS3t library and supporting JARs, plus Commons IO). Or you can download jets3t-decrypt-dist.zip, which contains the source and the reqired libraries. Once inside the ZIP you can run:

 java -jar Jets3tDecrypt.jar password encrypted.file 
                 > decrypted.file

The libraries and the Jets3tDecrypt.jar was packaged automatically by Netbeans 6.1, which is a lovely touch from an IDE.

QuickTime for Java

noreply@blogger.com (Richard) — Sun, 16 Mar 2008 16:18:00 +0000

A few months ago I was experimenting with QuickTime for Java. It's the binding between Apple's QuickTime "stuff" and the Java language, allowing a Java developer to invoke QuickTime on the Mac (and presumably also on Windows). The reason this appeals is that we do Java, and have accumulated a fair amount of Mac hardware.

To cut a long story short, my limited experienced shows that QuickTime, when compared to the standard Java image libraries, produced smaller images of higher quality, faster. It's unusual to get all three benefits together (smaller, faster, better). Too good to be true, even, which leads me to think I've screwed up someplace, but I've not spotted it yet.

The particular test that interested me was was taking a camera phone photo, resizing it and rotating it. Here's an example original:

Here's the rotation using tried-and-trusted AffineTransform plus ImageIO:

And here's the same transformation run through QuickTime for Java using the GraphicsImporter and Matrix objects:

Now, it's subtle but the QT4J image looks to have sharper colours, and seems to be a better representation of the original input. It's also 20k compared to the 76k using the Java 2D libraries, and the code runs 1.7 times faster. The downside: you need Apple hardware.

A few conclusions: it seems the Java 2D code doesn't just fall through to QuickTime on the Apple platform in any simple sense (which, I suppose I might have naively expected). Second, I suspect there's a lot of tuning that can be done in the Java 2D client usage to improve the quality, but QT4J seems to have good defaults.

(Before you ask, the dog's name is Jack.)

Getting Started with Scala

noreply@blogger.com (Richard) — Sun, 03 Feb 2008 14:44:00 +0000

Friday night was the first London Scala User Group meet-up, so it seems like the right time to say what I've learned so far about the language.

I'm not a functional programming person. My background, pre-Java and C, was dominated by POP-11 so it's fair to say I'm more comfortable with imperative coding than anything else. But that's kind of why Scala's a serious consideration for me: it doesn't force the functional stuff down your throat, but rather it's all there, object and functional, so you can pick and choose.

Other compelling aspects of the language are: it runs on the JVM, which has had a huge engineering investment to make it as fast as it is today; has Java-like features, but looks like it lets you get your work done with less lines of code; and it's strongly typed. In other words, it's comfy for a Java person, while putting you in a position to use the funky actors and functional stuff, and maybe make even better use of those multi-core machines.

Here's an example of less-lines-of-code thing. In Java, the type-safe idiom for iterating over a map is:

final Map<String, String> map 
    = new HashMap<String, String>();
map.put("dog", "woof");
map.put("cat", "meow");

for(Map.Entry<String, String> entry : map.entrySet())
{
  final String name = entry.getKey();
  final String value = entry.getValue();
  // do something with name and value here
}

The same code, just as strongly typed, in Scala is:

val map = Map[String,String]("dog" -> "woof", "cat" -> "meow")
for( (name,value) <- map)
{
 // do something with name and value here
}

Or, if you wanted that last part could be: map.foreach( (pair) => ...do something with pair._1 and pair._2 here.. ).

If you're interested in getting into this stuff, I found it useful to start with A Scala Tutorial for Java programmers PDF, then listen to Episode 62 of Software Engineering Radio, an interview with Martin Odersky on Scala (thanks to Dom for pointing that out to me).

After that, I think the best place to go is into your wallet and buy a copy of Programming in Scala: A comprehensive step-by-step guide. It's a pre-print, with quite a few errors, but I'm pretty sure they'll get cleaned up soon and it'll be a great text.

Tags: scala

UPDATE: oops, I forgot to escape the < and > tags in the Java example above, which hid the generic types of the map. Fixed now.