Fanf's blog

Make firefox remember "autocomplete=off" password fields

2011-11-17T17:45:00.000+01:00

Some site thinks that they better know than us what is security. For example, they want to prevent us to make firefox remember the login/password for them, and in the sametime, they don't allow to use a 30 char passphrase (because it does not contain a symbol, but six "!" is ok...).

If, like me, you are finding that behaviour as irrespectuous of your browsing experience as, say pop-ups, there is a trick:

install Firebug
on the page with the faulty password field, open Firebug.
use the blue mouse pointer in Firebug toolbar to select the password field
on the Firebug HTML tab, you should have a <input type="password" autocomplete="off"....> field selected
double-click on "off" to edit the value and change it to "on".
Now, enter you login/password as usual in the page form
when you hit "submit", Firefox should display the notification pop-up that allows to remember the login/password for that site.

Now, each time you are going to go on that page, firefox will autocomplete the login/password as usual.

Hop it will help other !

Installing ZeroMQ and Java bindings on Ubunu 10.10

2011-02-06T00:37:00.000+01:00

For some times now, I'm following the slow evolution of AMQP toward it's 1.0 release. In the trip, one traveler decided that the road was far too long, and complex, and choosed to take its independence: ZeroMQ is living its own adventure for some times now. And their choices are intersting, really focused and sharp, so I needed to see what can be done with that message system, and a bit of Scala.

So the first part was to install ZeroMQ and its Java binding into my computer, a Linux Ubuntu 10.10. It was quite easy, but as I didn't find a single post for the whole thing, I write that one as a memo, when in some days I will try to do it again and won't be able to remind the precise steps :)

Step 1: install recent ZeroMQ libraries

Before playing with some code, you need to install ZeroMQ libraries on your system. That library is on Ubuntu 10.10, but a more recent version seems to be needed for Java bindings. That's not a problem as some good will has made a PPA repository for them:

% sudo add-apt-repository ppa:chris-lea/zeromq

% sudo aptitude install libzmq-dev

That should install libzmq-dev (header files needed for the Java bindings) and the libzmq0 package - the core messaging system itself.

Step 2: get ZeroMQ binding

For that, you will have to clone the github repository of the project

% git clone https://github.com/zeromq/jzmq.git

And with that, you have a new jzmq directory with everything needed to build the Java bindings.

Step 3: build and install jzmq package

We are on a Debian based distribution, and ZeroMQ guys have the good taste to provide all what is needed to build a .deb for JZMQ, so let's just use the good work.
In the former jzmq directory, just do:

% ./autogen.sh

% dpkg-buildpackage -rfakeroot

And that's it. If all goes well, you should have a "jzmq_[some-version]_i386.deb" package on the parent directory of the one you are in. Just install it as usual:

% dpkg -i jzmq_[some-version]_i386.deb

And now, you can use ZQM from you Java code.

Some last notes

* don't forget to add the JNI library path in you JVM command line: use -Djava.library.path=/usr/lib
(/usr/lib should contains libjzmq.so, you can see it with dpkg -L jzmq)
If you the JAVA_HOME environment variable was correctly set when you buit the package,you may not have to add that parameter.
* libjzmq.jar is in /usr/share/java/
* you will find some Java examples here.

That's it! Enjoy a world of easy message distribution.

Martin Odersky au Paris Scala User Group le 31 janvier

2011-01-31T10:45:00.000+01:00

Après pas mal de temps en sommeil, je réveille ce blog pour faire suivre cette annonce: Martin Odersky, le papa de Scala, fera une présentation au Paris Scala User Group, ce lundi 31 janvier. Plus de détails sont disponibles ici et ici.

J'en profite pour relayer l'information du financement à hauteur de 2.3 Million d'Euros sur 5 ans de Scala par l'Europe, ce qui devrait permettre de lever les dernières incertitudes quant à la pérénité du langage.

Scala 2.8.1 is out!

2010-11-09T20:19:00.000+01:00

After a far shorter development cycle than for 2.8.0, Scala 2.8.1 reach us today.

More than 100 bugs were corrected, some of them really old (#36 !).

The great thing with that release is that for the first time ever, it is fully binary compatible with the previous one, Scala 2.8.0. With that and the creation of Scala Solution company, it seems to be really good insights toward Scala industrialization in the coming years.

Set-up Eclipse workspace in RAM

2010-07-27T17:03:00.000+02:00

I just published an article about how to set-up your Eclipse workspace in RAM to make I/O (almost) instantaneous. It was promised in the "Eclipse perfomance optimisation article", and now it's here: http://blog.normation.com/2010/07/27/set-up-eclipse-workspace-in-ram/

And like last time, any information about Eclipse optimization is much appreciated !

Java LDAP SDK for SyncRepl replication showcase

2010-07-18T19:49:00.000+02:00

I just published a post on my company blog about how to implement a SyncRepl client using two different Java LDAP SDK, Apache DS and UnboundID:

http://blog.normation.com/2010/07/18/java-ldap-sdk-for-syncrepl-replication-showcase/

SyncRepl is a replication protocol for LDAP, normalized in RFC 4533.

The demonstration is done with a showcase web application that display in real time modification done in an LDAP server.
The application, named Syweno, was developed in Scala, thanks to Liftweb and it's amazing Comet. It looks like:

Of course, update are synchronized thank to SyncRepl, and are propagated to the web page in real time thanks to Comet updates.

The code source is available on github here: http://github.com/fanf/syweno

Enjoy !

Scala 2.8.0 is out

2010-07-14T21:07:00.000+02:00

The most awaited Scala version of all time (ok, it's easy for now...) is out, at last !

Congratulation to every body who contributed to make it happens, and long life to Scala post-2.8.0. After a brilliant childhood, perhaps it is time for the unruly teenager to quieten down a little and conquer the industrial world !

The official link:
http://www.scala-lang.org/node/7009

Scala dreaded underscore @ PSUG

2010-07-01T18:23:00.000+02:00

(orignal content from http://blog.normation.com/2010/07/01/scala-dreaded-underscore-psug )

On the evening of June 30th 2010, the Paris Scala User Group organized its second event.
This time, there were two presentations:

in the first one, Alexis Agahi, our kind user group leader, made a feedback after one year of scala experience. It’s available here.
the second one was given by your servitor, and deals with each and every use case of underscores in the Scala language – I hope I didn’t miss any.
It’s available here.

See you next time on PSUG!

Optimizing Eclipse performances

2010-05-24T13:24:00.000+02:00

I just published an article about Eclipse perfomance optimisation, especially with the Scala IDE plugin, here : http://blog.normation.com/2010/05/24/optimizing-eclipse-performances/

This article mostly talk about generalities and gives some reference links about JVM tunning. It also contains some eclipse.ini examples, and point to reference topic on that subject.

A second, more involved article in which I will explain how to put your workspace into ram (and keep it synchronizes to disk, of course) will follow in a couple of days (ok, perhaps packed in weeks, depending of my work...).

Of course, any information about Eclipse optimization is much appreciated !

Maven2 bootstrap pom.xml for Scala with SLF4J and no-commons-logging

2010-05-18T16:24:00.002+02:00

Following an older post, this is the pom I use as a starting point for Scala project which uses maven.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.test</groupId>
 <artifactId>test</artifactId>
 <packaging>jar</packaging>
 
 <version>0.1-SNAPSHOT</version>

 <properties>
  <!-- UTF-8 for everyone -->
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  <!-- Other general properties -->
  <slf4j-version>1.6.0</slf4j-version>
  <logback-version>0.9.20</logback-version>
  <scala-version>2.8.0.RC2</scala-version>
  <scala-maven-plugin-version>2.13.1</scala-maven-plugin-version>
  </properties>

 <description>
  Starting pom
 </description>

 <repositories>
  <repository>
   <id>scala-tools.org</id>
   <name>Scala-tools Maven2 Repository</name>
   <url>http://scala-tools.org/repo-releases</url>
  </repository>
  <repository>
   <id>scala-snapshots.org</id>
   <name>Scala-tools Maven2 Repository snapshots</name>
   <url>http://scala-tools.org/repo-snapshots</url>
  </repository>

  <repository>
   <id>no-commons-logging</id>
   <name>No-commons-logging Maven Repository</name>
   <layout>default</layout>
   <url>http://no-commons-logging.zapto.org/mvn2</url>
   <snapshots><enabled>false</enabled></snapshots>
  </repository>

 </repositories>

 <pluginRepositories>
  <pluginRepository>
   <id>scala-tools.org</id>
   <name>Scala-tools Maven2 Repository</name>
   <url>http://scala-tools.org/repo-releases</url>
   <snapshots><enabled>false</enabled></snapshots>
  </pluginRepository>
  <pluginRepository>
   <id>scala-snapshots.org</id>
   <name>Scala-tools Maven2 Repository snapshots</name>
   <url>http://scala-tools.org/repo-snapshots</url>
  </pluginRepository>
 </pluginRepositories>

 <build>
  <sourceDirectory>src/main/scala</sourceDirectory>
  <testSourceDirectory>src/test/scala</testSourceDirectory>
  <plugins>
   <plugin>
    <groupId>org.scala-tools</groupId>
    <artifactId>maven-scala-plugin</artifactId>
    <version>${scala-maven-plugin-version}</version> 
    <executions>
     <execution>
      <goals>
       <goal>compile</goal>
       <goal>testCompile</goal>
      </goals>
     </execution>
    </executions>
    <configuration>
     <args>
      <arg>-target:jvm-1.5</arg>
      <arg>-make:transitivenocp</arg>
      <arg>-dependencyfile</arg>
      <arg>${project.build.directory}/.scala_dependencies</arg>
     </args>
     <jvmArgs>
      <jvmArg>-client</jvmArg>
      <jvmArg>-Xmx1G</jvmArg>
     </jvmArgs>
    </configuration>
   </plugin>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.1</version>
    <configuration>
    <source>1.6</source>
    </configuration>
   </plugin>
   
  </plugins>
 </build>

 <dependencies>
  <dependency>
   <groupId>org.scala-lang</groupId>
   <artifactId>scala-library</artifactId>
   <version>${scala-version}</version>
  </dependency>
  <dependency>
   <groupId>joda-time</groupId>
   <artifactId>joda-time</artifactId>
   <version>1.6</version>
  </dependency>
  <!--  test -->
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.7</version>
   <scope>test</scope>
  </dependency>

  
  <!--
   All the following is related to our will to NOT use Commong-logging
  -->
  <!-- use no-commons-logging -->
  <dependency>
   <groupId>commons-logging</groupId>
   <artifactId>commons-logging</artifactId>
   <version>99.0-does-not-exist</version>
  </dependency>
  <!-- no-commons-logging-api, if you need it -->
  <dependency>
   <groupId>commons-logging</groupId>
   <artifactId>commons-logging-api</artifactId>
   <version>99.0-does-not-exist</version>
  </dependency>
  <!-- the slf4j commons-logging replacement -->
  <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>jcl-over-slf4j</artifactId>
   <version>${slf4j-version}</version>
  </dependency>
  <!-- the other slf4j jars -->
  <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>${slf4j-version}</version>
  </dependency>
  <!-- using slf4j native backend -->
  <dependency>
   <groupId>ch.qos.logback</groupId>
   <artifactId>logback-core</artifactId>
   <version>${logback-version}</version>
  </dependency>
  <dependency>
   <groupId>ch.qos.logback</groupId>
   <artifactId>logback-classic</artifactId>
   <version>${logback-version}</version>
  </dependency>
 </dependencies>
</project>

Summary of my Scala Days 2010

2010-04-19T16:17:00.001+02:00

A great reception...

I had the immense luck to go to theFirst ScalaDays event organized by EPFL in Lausanne on 15/16 of April 2010.

It was an immense luck, because theevent was simply fabulous. And so, to begin, I really want to thanks the Scalateam, and especially Antonio Cunei for their amazing work oforganization: the welcome with the little kit with the little goodies and T-Shirt was a nice introduction, the food was really good, theboat trip and dinner on first day evening a really top-level dinner.

Safe for a volcanic eruption in Icelandwhich disrupted flights all around Europe and so impacted a lot of attendees, it could have been nearperfection.

... with great talks ...

And that is just for the organization: presentations were at the same level. Most of them were really good, and the choice between two sessions not always easy. Fortunately, presentation were recorded, and so should soon become available in line (I listed presentation I went to at the end). One little reproach: some of them would have deserve more time than allowed here, but that is near to nothing.

Akka presentation was somehow special. Jonas Boner and the Akka team did an amazing work in nomore than a year, from “just an other actor implementation” to afull feature actor framework à la Erlang OTP, with actor supervision and management, persistent datastructures, distribution, Software Transactional Memory (STM) integration, and all of that under thecommon umbrella of actor paradigm.

To me, Akka is more and more looking like theKiller App for Scala, a middle layer framework which will be more or less in all Scala applications in a near future, a little like Spring is for the Java world. It brings so much power with so littleboilerplate... So, if you don't know Akka, just go looking for itright now.

... and a bright future in sight for Scala

All along the event, there was afelling of “taking part of the starting point of something great”,perhaps a little like what were firsts Java one. Perhaps it was partly du to the fact that meeting about 155 Scala enthusiasts fromEurope, US, Japan, Australia and so on was a great moment - it was really good to finally put faces on mailing lists and IRC names (hello Miles,Josh, Timothy and all the others !).

But I believe that it was more than just that. Today, I'm pretty confident that Scala is here to stay and growth.

The most "symptomatic" announcement of that evolution of the language organization from the research sphere to a broader audience is the announcement that a Scala Foundation will be created to manage it.

So, that was a really wonderful event, and long life to Scala !

Ho – and I get my “Programming inScala” dedicated by Martin, it's the little thing that is makingthat event even more special to me :)

Presentations seen

So, that's the list of presentations Iattended, with a (really) brief description of them. Video of talks should me made available in a near future.

April, 15

15 morning - opening talk

A cool Opening Talk by Martin Odersky, focused on all the goodness brought by Scala 2.8, how it evolves from "just a little refactoring of Collection API" to a "3.0 without the name". Great.

15, morning

PEGEX by Kota Mizushima

or how to have combinator parser which looks like regexp. Interesting project, but a I think a little young for now... Keep an eye on it.

Scala Parallel collections by Aleksander Prokopec
Presentation of parallel collections arriving in Scala 2.8.1... It seems that it will be really great stuff, with good integration in existing collection API.

Developing the Scala bindings to the Fly Object Space by Channing Walton, Nigel Warren, Simon Kent

I miss a part of the beginning, but for what I saw, Fly Object Space seems to be a powerful framework for distributed computing.

15, afternoon, part 1

CCSTM: A library based STM for Scala by Nathan Bronson, Hasaan Chafi, Kunle Olukotun

A talk about what Software Transactional Memory (STM) implementation can be achieve with Scala from an ideal STM, really nice stuff – STM seems to be a hot topic, it is cool that what is one of the most interesting feature of Clojure is winning interest in Scala.

Lightweight language support for type-based, concurrent event processing by Phillip Hadler

Really nice technical presentation about how type information can leads to massive performance optimization in pattern matching.

Named and default argument in Scala by Luka Rytz

To me, this feature is one of the best of Scala 2.8. It was nice to see how the implementation was done.

15, afternoon, part 2

Specialization in Scala by Iulian Dragos

Specialization finally comes to Scala 2.8 ! For the first time, Scala has the opportunity to be able to do things faster than Java, namely automatically specializing method to native JVM type to remove unnecessary boxing/unboxing logic. Great stuff, even if it's just a beginning.

Leaky Monads – an experiment with automatic resources management by Josh Suereth

Or how to cleanly manage resources in Scala with a little bit of monad, but only when we need them.
Great presentation by Josh, with a lot of “déjà vu” feeling for me – most of the problem he talk about and the solution he found was alike whose I encountered when I did my monadic resource management of LDAP connections.

Type-safe SQL embedded in Scala by Christoph Wulfz

Cool stuff to make SQL a first class citizen in Scala, as XML is.

April, 16

The next day seems to have again raise the level of the event. For me, it was a fabulous set ofpresentations. All were really top level one, and allsubjects were great - well, or at least, I was the perfect target for them :)

16, morning keynotes

A really interesting keynote by KunleOlukotun, the man behind the heavily-multi-core Niagara processor. Heshows how to deeply embed polymorphic DSL in Scala, and it was kindof amazing. The Parallel and concurrent future seems to be bright inScala world.

16, morning

Scala @ Linkedin : distributed computed with Norbert by Chris Conrad

Really cool to see what Linkedin did with Scala, and their scaling and distribution problem are really nice ones (in the way a hard maths theorem is nice to prove ;).

Akka: Simpler scalabitity, fault-tolerance, concurrency & remoting throught actors by Jonas Boner, Victor Klang

As I already said, Akka is more and more looking like the killer app on Scala. Kudo to Jonas ans Akka team.

Scala IDE for Eclipse : retrospect and prospect for 2.8 by Miles Sabin

After years of purgatory (for users ;), Scala Eclipse IDE seems to finally be interesting again, thanks to Miles and all the hard work. A really bad point for Eclipse foundation and its autism regarding JDT evolution.

16, afternoon, part 1

sbt: design and implementation by Mark Harrah

SBT, the build system that will save all of us from Maven – thanks Mark, and congrats for the work

Scala Modules: a Scala DSL to ease OSGi development by Heiko Seeberger

A “small” library to make OSGi use more user-friendly, and a lotof interest toward it. Sometime, syntax and cleanness IS important (subliminal message to all Java coders who don't see the problems with Java boilerplate)

Sneaking Scala into your organization by David Copeland

Even if I don't have that problem – in my company of four people, all the two developers are Scala experts ;), the talk was really interesting and well thought. Hope that a lot of people will follow these advices :)

16, afternoon, part 2

Their was no presentation in the last afternoon, but a workshop in which attendees were able to summarize their thought about Scala - what is missing, what has to be done, etc. Unfortunately, I had to leave before than the restitution was done, and missed it. So, for that, I'm like all of you: waiting for blog/video to know what happened !

And that's all, until next year (in U.S ?) !

Scala Days tomorrow !

2010-04-14T14:47:00.000+02:00

In a few hours, I'm going to take the TGV for Lausanne, to attend first Scala Days !

There seems to be a lots of really good conferences, and it will be the opportunity to finally met a lot of irc/mailing list names !

Embed OpenDS in your application

2010-04-10T19:15:00.000+02:00

I just created a github project that shows what one has to do to configure and start OpenDS LDAP directory from a Java application, for example to run unit tests.

Most of the code is a direct transcription of information found on OpenDS wiki[1].

Along the commits, I tried to remove most of the unused configuration for the proposed goal, and I ended to replace the Berkeley DB backend by a memory one.

The source code is here: http://github.com/fanf/opends-simple-config

Feel free to remove even more unused configuration, or propose things to make OpenDS start time even faster.

Enjoy !

[1] https://www.opends.org/wiki/page/CreatingAnOpenDSInstanceForEmbeddedUse
https://www.opends.org/wiki/page/ControllingOpenDSFromAnotherApplication

Scala Unix file permissions DSL

2010-03-17T23:43:00.000+01:00

Scala native DSL capabilities are astonishing. I just created some Scala object to mimic Unix file permission representation and "chmod" interaction, and I'm rather pleased of the result

Only user", "group" and "other" permission are managed - so no setuid, setgid or sticky bit.

Perm objects

They are simple immutable permission objects with a nice toString and an octal representation:


scala> val p:Perm = wx
scala> w.toString // "-wx"
scala> w.octal // 3

You can combine permission to obtain new permissions:


scala> w+r  // rw-
scala> rwx-w // r-w

FilePerms objects

They keep a group of three mutable permissions.You can create a new File permission object from octal values:


scala> val perms = FilePerms(777)

Or from Perm object:


scala> val perms = FilePerms(rw,rw,r)

Like Perm, they have nice string and octal representation:


scala> val perms = FilePerms(777)
scala> perms.toString //rwxrwxrwx
scala> perms.octal // 777

Missing values are initialized to "no permission":


scala> val perms = FilePerms(77) //rwxrwx---
scala> val perms = FilePerms(rw) //rw-------

And of course, you can change permissions:


scala> val perms = FilePerms(77) //rwxrwx---
scala> perms.g-wx  // rwxr----
scala> perms.ugo+x // rwxr-x--x
scala> perms.a-wx  // r--r-----

The binding of theses objects with Java IO with the goal to actually set file permissions is let as an exercise for the reader ;)
It's available on gist here: http://gist.github.com/335791. To test it, simply copy the file content, fire a Scala REPL, start an object declaration, past the content of the file, close you object, import its content, and play:


scala> object p { [enter]
  | [here, past the content of the file]
  .....
  | }
defined module p

scala> import p._
import p._

scala> FilePerms(644)
res0: Option[p.FilePerms] = Some(rw-r--r--)

Enjoy !

PS: if you have an idea about how to mimic chown, I would appreciate. For now, all I get is:


chmod( ug(_)+rw, filePerms)

Not really nice.

Scala 2.8 Beta 1 is out !

2010-01-27T17:48:00.002+01:00

Today, the first official "Scala 2.8 Beta" was released. It was awaited, and for really good reasons !
Just look at the announcement summary to see all the goodness available: http://www.scala-lang.org/node/4587

I would like to thanks all the people at EPFL and all other contributors around the world to provide us with such a good language and awesome libraries/tools for our daily work - both production ready thanks to Java existing ecosystem and Start-up friendly (ok, no argument here, I just like that language :)

Downloads are available here: http://www.scala-lang.org/downloads

Scala and Spring 3 JavaConfig

2010-01-20T09:36:00.005+01:00

Scala, Spring 3, Actor, REST, IoC configuration by code...
... and well, I should be able to put some other buzz words in that title, perhaps agile and Scrum ?

I wanted to test Spring 3 "configuration via code" new feature, and especially how well it works with Scala.

As a Tapestry 5 (former) user, I'm a great fan of IoC configuration done in Java (or Scala). From a developer point of view, it's so much more easy and robust (especially refactoring prone) to have access to a real, type safe language in place of an ersatz like XML... and most of the time, it's also much less verbose.

The application
I needed a pretext and decided to build a trivial webapplication that allows to upload files to some URL, and post-processthem - a rather usual need in a web-application. That will allow to test Spring 3 new "REST"features, a bit of Expression Language, and put in a little Scala Actorto let the (long) processing be done asynchronously.
I also used maven, and Slf4j with NoCommonsLogging to be able to use Slf4j with Spring.

What exactly does the application:
- wait uploads on a REST endpoint URL;
- when an upload comes, save it into a temporary file;
- signal the file's availability to a "file processor". That processing may take a looooooong time to process (for example, it's a big XML report, with a lot of parsing, input validation, graphs generation, etc), and so, the processing should be done in a side process.

Results
Everything comes along really well, and the result is available on github.

To test it, you will need a JVM and Maven (if you haven't done it yet and are not limited by production constrains, just go download the last 1.6 JVM (1.6.0_18), the performances improvements with the last two releases are impressive)

% git clone git://github.com/fanf/scala-spring3-upload.git

% cd scala-spring3-upload

% mvn jetty:run

You should have a Jetty server up and running on localhost.
Now, you can upload a file to http://localhost:8080/upload, and see that the upload is processed and HTTP code returned, and then an asynchronous process is launched to process the file - well, actually it just waits 10 seconds and delete it.
On Linux, you can use Curl to post files:

% curl -F FileToUploadName=@/path/to/the/file/to/upload http://localhost:8080/upload/

Details about the project
Here comes the different files and their purpose:

src/main/webapp/WEB-INF/

It contains usual servlet configuration files, in XML :
- web.xml : standard Java servlet config file~~, nothing to see here.~~ with a reference to the annotation based context loader and the AppConfig.scala file.

~~- upload-servlet.xml : Spring servlet config file. It's this one that is Spring default enter point, and it contains an entry point to the Scala file used for bean configuration, and to the prope~~

I just don't understand why this last file is needed. It's where you feel that JavaConfig was an afterthought in Spring... Couldn't have we a convention in place of that ? Something like "put your master configuration code in that package" ? All in all, it's small pain to have to write that file, but it also bring really little information.

UPDATE: as Chris Beams shows me, I should have RTFM more carefully. It's now possible (I do believed it wasn't in first RCs), and I updated the sources to have a full ScalaBased configuration.

src/main/scala/org/test/upload

That package contains the code to receive file (UploadEndpoint.scala) and process them (FileProcessor.scala).
As you can see, there is very little code, and most of it is self-explanatory.

src/main/scala/org/test/upload/config

That last package only contains the AppConfig.scala file, the place where Spring IoC configuration is done.
I really like the cleaness of that file, compared to what may have been the equivalent XML one.
The default sleepTime value is especially cool, typically a things hard to do when you only have XML

Conclusion
This little project could be a good starting-point if you want to use Spring 3 with Scala, or Slf4j with Spring.
I'm also rather impressed by how much little code is needed with Spring 3 to configured the REST endpoint.
And building little asynchronous services thanks to actor is just too simple (OK, here it's a toy, but if you want serious business with actor, look at AKKA).

Happy new year 2010

2010-01-09T18:43:00.000+01:00

For me, year 2010 will be a big switch in my life... hopefully for the best !
So, I wish you all the best things for this last year of the first third millennium's decade !

Happy new year !

Bootstrap GWT2 with maven, UiBinder and i18n

2009-11-12T11:41:00.001+01:00

I'm setting up a boostrap project for GWT 2 witch would use maven 2, UiBinder and i18n.
The idea is to centralize resources about UiBinder and test GWT 2, the result being used as a template project for real GWT 2 projects.

I'm quite new to GWT (2 days old...), so it is also a learning project. If it could be of any use for you, don't hesitate to use it - or enhance it, or make comments :)

For now, it's based on GWT 2.0.0-ms2, and some configuration may be specific to my environment (Linux&Firefox 3.5).

It's available here: http://github.com/fanf/gwt2-mvn-bootstrap

Maven2 bootstrap pom.xml for SLF4J and no-commons-logging

2009-11-10T14:44:00.003+01:00

Each time I start a new Java project with Maven 2, I need to write the same dependencies again and again: SLF4J and no commons-logging because it's evil (and SpringFramework seems to want to keep it), Joda Time by default, some properties, etc.

So, that's the template pom.xml I use for the bootstrap, if it may help anybody here (it uses logback for logging, as it's more efficient than Log4j with SLF4J, but feel free to use what you want):


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.test</groupId>
  <artifactId>test</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>

  <properties>
    <!-- UTF-8 for everyone -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <slf4j-version>1.5.8</slf4j-version>
    <logback-version>0.9.17</logback-version>
  </properties>

  <description>Template for project without Commons-logging</description>

  <repositories>
    <repository>
      <id>no-commons-logging</id>
      <name>No-commons-logging Maven Repository</name>
      <layout>default</layout>
      <url>http://no-commons-logging.zapto.org/mvn2</url>
      <snapshots><enabled>false</enabled></snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
  </pluginRepositories>

  <build>
    <plugins>
    </plugins>
  </build>

  <dependencies>
    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
      <version>1.6</version>
    </dependency>

    <!--  test -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.7</version>
      <scope>test</scope>
    </dependency>

    <!--
      All the following is related to our will to NOT use Commong-logging. Never. 
      And framework we depend on won't bring commons-loggin nether (I'm looking at
      you, stringframework).
    -->
    <!-- use no-commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>99.0-does-not-exist</version>
    </dependency>
    <!-- no-commons-logging-api, if you need it -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging-api</artifactId>
      <version>99.0-does-not-exist</version>
    </dependency>
    <!-- slf4j commons-logging replacement -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>${slf4j-version}</version>
    </dependency>
    <!-- other slf4j jars -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j-version}</version>
    </dependency>
    <!-- using slf4j native backend -->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-core</artifactId>
      <version>${logback-version}</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>${logback-version}</version>
    </dependency>
  </dependencies>
</project>

Clone objects with arguments override in Scala 2.8: best practices ?

2009-10-24T18:32:00.000+02:00

I'm actively looking for best practices and patterns about how to create clone objects in Scala, with the possibility to change some values of the cloned object along the way.

I have the usual concern of the Java world on that topic: I would like to avoid Java "clone", I want to be able to use the pattern in a class hierarchy, I want to have the minimum amount of code (or at least, the simplest possible) to write in domain class to support my cloning API.
And as I'm in Scala, I want to deal with both vars and vals, if possible in the same consistent way.

Actually, I want to provide to my libraries consumer an effective way to do things like that (where *Child* extends *Parent* class):

    val p = new Parent("some value")
    // simple cloning
    val p2 = p.copy
    //clone, and change a val and a var along the way
    val p3 = p.copy(p_val1 = "new value for val", p_var1 = "new value for var")

    //and same things apply for children of Parent:
    val c = new Child("some parent value", "some child value")
    //override child val/var and/or parent val/var in the same fashion
    val c1 = c.copy(p_val1 = "new value for val defined in Parent class",
                    c_val1 = "new value for val defined in Child class",
                    p_var1 = "new value for var defined in Parent class",
                    c_var1 = "new value for var defined in Child class" )

As Scala 2.8 is advertised with "default and named arguments", such things should possible (well, hopefully easy too ;).I came with this solution:

class A(val val_a:String)  {
    var var_a = ""
}

object A {
    def merge[T](t:T)
    (
        var_a : String
    ) : T = {
        t match {
            case x:A => x.var_a = var_a
            case _ => error("")
        }
        t
    }
    
    def copy(source:A)
    (
        val_a : String = source.val_a, 
        var_a : String = source.var_a
    ) : A = merge(new A(val_a))(var_a)
}

class B(override val val_a:String, val val_b : Int) extends A(val_a) {
    var var_b = 0
}

object B {
    def merge[T](t:T)
    (
        var_a : String,
        var_b : Int
    ) : T = {
        A.merge(t)(var_a) match {
            case x:B => x.var_b = var_b
            case _ => error("")
        }
        t
    }
    
    def copy(source:B)
    (
        val_a : String = source.val_a,
        var_a : String = source.var_a,
        val_b : Int = source.val_b,
        var_b : Int = source.var_b
    ) : B = merge(new B(val_a,val_b))(var_a,var_b)
}


class C(override val val_a : String) extends A(val_a)

// ***************** 
// Example of use
// ***************** 

object TestCloning {
    
    def main(args:Array[String]) {
        val a1 = new A("la_init")
        a1.var_a = "ra_init"
            
        val b1 = new B("lb_init",1)
        b1.var_a = "rb_init"
        b1.var_b = 10

        //example with A

        val a2 = A.copy(a1)()
        assert(!(a1 eq a2))
        assert(a2.var_a == a1.var_a)
        assert(a2.val_a == a1.val_a)
        
        val a3 = A.copy(a1)(val_a = "la_mod")
        assert(a3.var_a == a1.var_a)
        assert(a3.val_a == "la_mod")
        
        val a4 = A.copy(a1)(val_a = "la_mod", var_a = "ra_mod")
        assert(a4.val_a == "la_mod")
        assert(a4.var_a == "ra_mod")

        val a5 = A.copy(new C("foo"))()
        assert(a5.var_a == "")
        assert(a5.val_a == "foo")

        val a6 = A.copy(b1)()
        assert(a6.val_a == "lb_init")
        assert(a6.var_a == "rb_init")
        
        //with B
            
        val b2 = B.copy(b1)()
        assert(b2.val_a == "lb_init")
        assert(b2.var_a == "rb_init")
        assert(b2.val_b == 1)
        assert(b2.var_b == 10)
            
        val b3 = B.copy(b1)(var_b = 5, val_a = "lb_mod")
        assert(b3.val_a == "lb_mod")
        assert(b3.var_a == "rb_init")
        assert(b3.val_b == 1)
        assert(b3.var_b == 5)
            
    }

That solution seems to work, and allows to do the kind of use case I wanted to build.
But it seems not satisfactory at all for (at least) these reasons:
1/ - the trailing "()" in real clone without override is mandatory and doesn't look right;
2/ - it seems to be a lot of tedious code to write in each class, and so seems to be really error prone;
3/ - I'm not at ease with the merge method, but I can't say why exactly;
4/ - I don't like to much the factory approach.

1/ could be easily addressed if in place of only a copy(source:X)(.....) we define a couple of method :

    def copyWith(source:A)( ... ) : A = merge(...)(...)
    def copy(source:A) = copyWith(source)()

3/ and 4/ are just feelings, and so could be shut up for now.

But 2/ is a real concern, and I would like to find a way to externalize more code in traits, so that domain classes have only simple, short code to write to provide a clone API.

So Scalazy, what are your best practices about the cloning topic in Scala ?

ActiveLDAP in Scala : LDAP on the JVM, in a shell !

2009-10-12T21:42:00.004+02:00

Update: typos only

Until a really recent time, LDAP in the JVM, trougth JNDI API, was a nightmare of usability. Just connecting to an LDAP directory with a simple login/pass was worth a dozen lines of really unatural code (and I'm almost not exagering)

Hopefully, the situation is evolving, and there is several projects willing to provide a better LDAP SDK on the JVM.

Among them, there is UnboundId's one. I started to play with it, and it's quite delighting to be able to use a good API to do your work !

So it gives me an idea : how this SDK could be pimped thanks to Scala to be used in command lines, in a ruby ActiveLDAP fashion ?

And things are coming along really well. It's just a start, but this is an example of a Scala REPL session with my version of Scala ActiveLDAP :

scala> import test.activeldap._
import test.activeldap._

scala> import LdapFilter._
import LdapFilter._

scala> val p = new SimpleAuthLCP(baseDn = "dc=example,dc=org",authDn = 
"cn=admin", authPw = "secret pass")
p: test.activeldap.SimpleAuthLCP = [cn=admin@localhost:389 (base: 
dc=example,dc=org) by password authentication]

scala> val users = new MetaActiveEntry(prefix = "ou=people",  
rdn = "uid" , classes = Set("top","person","organizationalPerson","inetOrgPerson"), 
provider = p )
users: test.activeldap.MetaActiveEntry = test.activeldap.MetaActiveEntry@c85a33

scala> val user = users.find()(0)
user: test.activeldap.ActiveEntry = uid=42,ou=people,dc=example,dc=org

scala> user.details
res28: java.lang.String = Entry(dn='uid=42,ou=people,dc=example,dc=org', 
attributes={Attribute(name=objectClass, values={'inetOrgPerson', 
'organizationalPerson', 'person', 'top'}), 
Attribute(name=sn, values={'Bar'}), Attribute(name=cn, values={'Foo'}), 
Attribute(name=mail, values={'foo@bar.com'}), Attribute(name=uid, values={'42'})})

scala> user("uid") = "43"

scala> user.save

scala> users.find()
res31: Seq[test.activeldap.ActiveEntry] = ArrayBuffer(uid=42,ou=people,dc=example,dc=org,
uid=43,ou=people,dc=example,dc=org)

scala> user("mail") = Seq("foo@bar.com","foo_bar@bar.com")

scala> user.save

scala> users.find(EQ("uid","43"))(0).details
res34: java.lang.String = Entry(dn='uid=43,ou=people,dc=example,dc=org', 
attributes={Attribute(name=objectClass, values={'inetOrgPerson', 
'organizationalPerson', 'person', 'top'}), Attribute(name=sn, values={'Bar'}),
Attribute(name=cn, values={'Foo'}), Attribute(name=mail, values={'foo@bar.com', 
'foo_bar@bar.com'}), Attribute(name=uid, values={'43'})})

scala> user.delete

scala> users.find(EQ("uid","43"))
res36: Seq[test.activeldap.ActiveEntry] = ArrayBuffer()


scala>

There is a really nice feature brought by Scala 2.8 for this kind of API: named and default parameters. I used it in the previous sessions to define the connection: host and port were not provided (default to localhost:389), but you can specify them if you need :

 scala> val p = new SimpleAuthLCP(
        | authDn = "cn=manager",
        | authPw = "secret password",
        | host = "an.other.host.com",
        | port = "1389",
        | baseDn = "dc=company,dc=com"
        | )

It's just a begining, and there is a lot of other nice features from Ruby ActiveLDAP that could be added...

Alternative languages for the JVM @ OpenWorldForum Paris

2009-10-01T18:24:00.003+02:00

Today, a was kindly invited by Alexis Moussine - Pouchkine to be the Scala advocate in a roundtable about alternative languages on the JVM, during a session about the Futur of Java in Open World Forum meeting in Paris.

The sessions was brief (3 parts of about 30 minutes), and in my feeling a bit outside the main topic of OpenWorldForum which was more about open source at a strategic an politic level, but (surprisingly for me) our room was quite crowd, with interested people.

Alexis gave the first presentation about the state of Java and OpenJDK, and final presentation, about forthcoming JavaEE 6. As always, I really liked to hear and see Alexis make the show, his presentations were really good, and he defenitly deserve his "JavaEE and Glashfish Evangelist" title.

The roundtable begun with a presentation from Stéphane Fermigier of the way accomplished by Java and the JVM as a platform for other language since it's first release back in 1996.
Afterwards, Guillaume Laforge (of course for Groovy) and I (for Scala) talked about our prefered language, the "welcomeness" of the JVM plateform, the always funny debate about dynamically and statically typed languages, and the fact that we seem to be going to a world of "polyglotism", where multiple languages would cooperate on top of a highly industrialized, robust and efficient VM, and be selected for their adequacy to the task to accomplish - all that things mixed up with attendees questions.

And then, even if we went past the given 30 minutes (well, actually, even went past the 40 minutes...) it was already time to stop.

It was a really pleasant meeting, and I'm really happy to see that Groovy is now a first class citizen in the Java world, that Scala is beyond the status of new intriguing thing and becomes to be evaluated in different places, and that we can say "functional programming" elsewhere than in an University or some strange startup without being looked as a dangerous, non business compliant hacker.

Faster log in in Ubuntu 9.10 "Karmic Koala" and e17

2009-09-20T16:40:00.000+02:00

I'm a long time user of Enlightenment 17, or e17. I mean, a really long time user, since I used it since the end of 2004 or so. If I kept it for so a long time dispite of all its rough edges, it's because I love a lot of things in e17, like the default windows and mouse focusing behaviour, the possibility to have a lot of cool and usefull desktop effects with a real open source driver that doesn't support 3D acceleration.

But what I like above all the the speed of the the environement. In e17, everything seems to be quick and responsive - well almost everything, Firefox and OpenOffice are what they are ;)
For example, the login process in e17 takes a couple of second. I mean, really a couple: I validate my user/password in GDM, and hop, my desktop environement is fully-loaded and usable.

OK, so why I'm talking about that ? Lastly, I tried the new Ubuntu Karmic Koala Alpha 5. Before anything else, I do know what alpha means, and I'm not saying anything against Ubuntu, things are expected to enhance until end of october.
Among a loads of other things, Karmic Koala introduces a new transition screen when X is loading, in order to smoothen a little transitions : XSplash. The problem is that XSplash doesn't seem to be aware of the speed of e17, and when you login, it loops for quite a long time (perhaps 20 seconds ?) before letting the desktop be shown.

So, the solution is simply to disable XSplash for the login, and let e17 loads within its 2 seconds:
in the file /etc/gdm/PreSession/Default comments the things related to XSplash, or if "Default" file only contains XSplash related things, disable it like that (of course, be aware that as Ubuntu is only in alpha phase, this file may be use for other things that Xsplash in the future, and you can break other things with that) :

mv /etc/gdm/PreSession/Default /etc/gdm/PreSession/Default.disabled

That's all ! Now, you can enjoy the lightning login speed of e17 on Ubuntu Karmic Koala.

Why simple XML processing is so painful in Java ?

2009-08-14T13:39:00.001+02:00

Note: this article is of little interest to learn Scala XML apis, there is far better coverage of them elsewhere in the web, like here and in details here. It's more like a rant against Java, which makes things painful where it should shine...

Nowadays, XML is more or less everywhere, especially when there is data to dispatch between applications, protocols, program languages and other technologies - and no, Json is not (yet ?) as ubiquitous as XML for that.

And still nowadays, parsing simple XML documents in Java is a pain.

Well, actually, I don't speak about complex, normalized documents with defined, huge XSD schemas (perhaps in this situation, you can afford to invest time in Jaxb or Jibx to do it the right way), nor simpler scenario, but where you want to have a real XML/Object mapping - XStream is a kind here, and really does a good job.

I'm talking about kind of XML documents which are more like a database dump, that may be long and with rather deep tree structures, and where you just want to cherry pick some values - of course, in different parts of the tree. You know, when you just want to test ideas, and you have to implement a quick, working thing to see if the overall architecture works [1], and you really don't want to build a full POJO tree to change or erase it the next hour.

That's a kind of place where Java XPath API (jaxp) should shine. But it doesn't. I'm not saying that it's difficult, nor that it doesn't actually work, but that it's painful and you end up with lines and lines and lines of burden (cast, expression compilation, redefinition of higher function than the ones provided by API to do common things, etc) in code that should just expose your intention at first sight.

Well, lets take a super simple example.

Lets say that I have this kind of XML data :


<?xml version="1.0" ?>
<request>
  <id>463516</id>
  <timestamp>1250240149028</timestamp>
  <information>
    <person>
      <id>463</id>
      <firstname>Alex</firstname>
      <lastname>Bar</lastname>
      <age>34</age>
      <gender>male</gender>
      <address>
        <street>136 W 9th St</street>
        <city>Casper</city>
        <country>United States</country>
      </address>
    </person>
  </information>
</request>

And I only want to take the timestamp, add the city in a male or female list depending of the gender, and if age > 18, increment the count off adults.

I have a data container that looks like[2]:


public class Data {
 public static final String MALE = "male";
 public static final String FEMALE = "female";
 
 private final Long timestamp;

 private final Map<String, List<String>> stats;

 private int adults;
 
 public Data(Long timestamp) {
  this.timestamp = timestamp;
  this.stats = new HashMap<String, List<String>>();
  this.stats.put(MALE, new ArrayList<String>());
  this.stats.put(FEMALE, new ArrayList<String>());
 }
 
 public void addMale(String city) { this.stats.get(MALE).add(city); }
 public void addFemale(String city) { this.stats.get(FEMALE).add(city); }
 public Long getTimestamp() { return timestamp; }
 public void incAdults() { this.adults = this.adults + 1; }
 
 @Override
 public String toString() {
  StringBuilder sb = new StringBuilder();
  sb.append("time: ").append(this.timestamp).append("\n");
  sb.append("female: ");
  for(String s : stats.get(FEMALE)) {
   sb.append(s).append("; ");
  }
  sb.append("\n");
  sb.append("male: ");
  for(String s : stats.get(MALE)) {
   sb.append(s).append("; ");
  }
  sb.append("\n");
  sb.append("adults: ").append(adults);
  return sb.toString();
 }
}

OK, I now this the simplest Java class I came with to implements this logic:


/*
 * So, you need a lots of imports,
 * and you must have jaxp-api
 * somewhere in you path
 */

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;


public class ParseData {
 
 /*
  * the "throws Exception" is here to try to remove a 
  * lot of burden, but of course, don't do that at home !
  */
 public static void main(String[] args) throws Exception {

  DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
  domFactory.setNamespaceAware(true); 
  DocumentBuilder builder = domFactory.newDocumentBuilder();
  Document doc = builder.parse("data.xml");
  XPath xpath = XPathFactory.newInstance().newXPath();
  
  // now, I start to actually do something interesting
  Data data = new Data(Long.parseLong(
    s(xpath, doc, "//request/timestamp/text()")));

  XPathExpression xe = xpath.compile("//request/information/person");
  NodeList nodes = (NodeList)xe.evaluate(doc,XPathConstants.NODESET);
  
  for(int i = 0; i < nodes.getLength() ; i++) {
   String gender = s(xpath, nodes.item(i), "//gender/text()");
   String city = s(xpath, nodes.item(i), "//address/city/text()");
   
   if(Data.MALE.equals(gender.toLowerCase())) {
    data.addMale(city);
   } else if (Data.FEMALE.equals(gender.toLowerCase())) {
    data.addFemale(city);
   }
  
   if(Integer.parseInt(s(xpath, nodes.item(i), "//age/text()")) >= 18) {
    data.incAdults();
   }
  }
  
  System.out.println(data);

 }
 
 /*
  * Why do I have to do that ? Even it it's two lines, 
  * I just let you imagine the look of the
  * main loop without this function...
         * But why the Xpath API doesn't have the four of five
  * functions alike defined for each XPathConstants types ? 
  * Before actually begin to use the API, I have to redefine it...
  */
 public static String s(XPath xpath, Object root, String expr) throws Exception {
  XPathExpression xe = xpath.compile(expr);
  return (String)xe.evaluate(root, XPathConstants.STRING);
 }

}

As you can see, there is a lots of type cast, and I quickly loose what I'm looking for, even in a so simple class with so little cases and data to retrieve.

So, at the end, what did I do ? Just use the Scala XML library. Same logic, in a scala class:



import scala.xml.XML

object ScalaParseData {

 def main(args:Array[String]) {

  val doc = XML.load("data.xml")
  
  val data = new Data((doc\\"request"\"timestamp" text).toLong)
  
  for(person <- (doc\\"request"\"information"\"person")) {
   val city = person\"address"\"city" text
   
   (person\"gender" text).toLowerCase match {
    case Data.MALE => data.addMale(city)
    case Data.FEMALE => data.addFemale(city)
   }
   
   if((person\"age" text).toInt >= 18) data.incAdults
  }
  
  println(data)
 }
}

In both case, the same output is printed in stdout:


time: 1250240149028
female: 
male: Casper; 
adults: 1

Even if you never look at Scala, you understand what is the global logic, what piece of data are looked for. Nothing to add :)

[1]: ok, the question here is: is Java the right language for that ? Well, it seems that the answer, for whose who still had doubts, is DEFINITLY NOT.

[2] OK, even the data container is complex, and Java really miss Tuples structure to prototype efficiently. In such a process, you just don't want to spend time writing POJOs and POJOs and POJOs that are only, meaningless container for two string lists and a long, even if you IDE does 90%of the job. If you are interested by more efficient data structure for Java, you should go and look for Functional Java, that's a really cool project - and at least, you will have tuples (named "products" here), function class (to not have to define again and again that Filter<E> { boolean filter(E element); } class)

A Tour Of Scala @ OSSGTP - Paris OSS user group

2009-06-07T19:32:00.003+02:00

Thursday (4 june 2009), I gave a presentation about the Scala programming language to the OSSGTP group (Open Source Software - Get Together in Paris).

This presentation is available under Creative Common BY-NC-SA, so you are free to download the source, use it, enhanced it and redistribute it !

A Tour Of Scala

View more Keynote presentations from fanf42.

PS: let me know if you see any errors, or if you use it, it will make me happy
PPS: I took inspiration from "Programming in Scala" book by Martin Odersky, Lex Spoon and Bill Venners, "Pragmatic Real World Scala" by Jonas Boner, "A Scalable Language" by Martin Odersky and "The feel of Scala" by Bill Venners - thanks for their great presentations and books !

100 problems solved on Project Euler

2009-05-28T13:46:00.005+02:00

Today, I just finished my 100th problem on Project Euleur, using Scala - of course.

Project Euler is a really good way to learn a language on small problems, to see its different sides and idiomatic constructs, and be confronted on performance/algorithm optimization choices - that teaches you to feel when something migth make you gain an order or two of execution time / memory consumption, and when you are working for peanuts.

OK, you won't see how the language solves big architectural design and maintenance problems, but you will learn if the language fits your mind, and if you are able to get things done with it. And definitly, Scala shines on such problems, and completly fits my mind.

So, it was a really good learning experience. Now, I need to test it on bigger problem, to see how it goes on the long run, and I have some ideas for that...

So, Sun is no more - Oracle is one of the big three

2009-04-21T09:35:00.006+02:00

At the beginning, I though I wouldn't write about it. After all, all the Internet is talking about it, and I'm just a little developer, with my little biased view of the world through my small experience. But the thing may be so impacting for my daily life, and well Sun was such an uncommon adventure of a company, I wanted to mark the day. The following is just my thoughts on that big thing, take them as no more than that.

So, yesterday Oracle announced to the world that they bought Sun for something like $7,4 Billions.
My first feeling was (is) "better being Oracle than IBM". All in all, it may even be good. But wow, what a concentration ! Now, the "business software solution" industry is shared among 3 bigs (MS/IBM/Oracle), and that's all. And Oracle owns the database market, both opensource and proprietary.

So, more in details, I thing that there is 3 domains of Sun that will be push foward by Oracle:
- MySQL ;
- the Java platform ;
- Hardware, Solaris and related knowledge.

Hardware and Solaris
The hardware and Solaris part are, I think, the domains with the clearer future : they will become the preferred platform for hight performance, highly tuned, very very expensive SGBD server and Business app server.
For me, that's the main point why Oracle is better than IBM : Oracle WANT these missing layers in their integrated stack, and IBM would have killed Sparc and Solaris, their old rivals. So, be prepared for Sparc/Solaris/Oracle SGBD killer servers, with Sun^W Oracle storage solutions, to make run your Sparc/Solaris/Weblogic business application servers.
Moreover, we could see some really cool and great things happen in the filesytem domain: just think that ZSF, btrfs and OCFS(2) fathers are now in the same company...

MySQL
I don't fear anything for MySQL. Oracle bought InnoDB not so long time ago, they already thought to buy them at the same moment Sun did. MySQL could become their "low level" offer, and all the big customer will be encourage to switch to Oracle DB with wors like "you know, we own both system, but clearly you, you need our most expensive one, the one that works best".

The Java language and the Java platform
Oracle have a lot of business application build on Java, and now they own the platform. They also have two JVMs.
Oh, and they make money with the techno, something Sun never succeeded to do.

So clearly, Java was a BIG motivation for the operation, and Oracle will want to promote at the maximum its platform against opponents. And a better platform whould lead to better softwares, no ? :)

The real question is about policies. What will happen to JCP ? In the current model, the guerilla beside Sun and IBM was famous, things could become even worst now... Will Oracle try to follow MS way in the management of its software platform evolution to avoid it ?

Less clear points
My real interrogation are around Sun existing application, and Oracle behavior toward OpenSource.

Netbeans may be a winner here, even if Oracle seem to have taken interests onto Eclipse. But what will happen to Glassfish ? The v3 is amazing, it's still a reference implementation of JEE, but there's Weblogic... So, Glassfish has the low level / test solution, and Weblo for "real things" ?

Even more frighting, what will happen to Sun's (really good) Identity and Access Management solution (OpenDS, OpenSSO, Identity Manager, etc) ? Oracle was a frontal concurrent here, I don't see them keep both offers...

And what will happen to the Sun clear move toward open source ? Oracle is not reluctant to OSS (I mean, at least not more than IBM), and they contributed some really nice stuff in the last years (btrfs for example). But they are not exactly an open source company, to say the least.

So, what next for us ?
So, my best hope is that Oracle will free a lot of technical/low level stuff, like filesystem, a JVM, etc. That kind of stuff has little added value (in dollars) for them, and they might attracts a lot of geek / small companies to work on and make them better. On the other hand, Oracle keep their higher level, more business oriented, and far more profitable middlewares as incomes sources.

To conclude, there is one thing that I'm sure of: "It's tough making predictions, especially about the future", as would say Yogi Berra. Or Neils Bohr. Or Mark Twain. Or was it Robert Storm Petersen ? Well, at least, what is done is done, and let's see what will happen !

Tapestry 5 - Scala : view article in HTML, JSON or XML

2009-03-25T18:20:00.003+01:00

We must have the REST in our blog, it will attract a lot of investors

The last time we saw how to make basic CRUD functionalities for the blog. That was quite a long time, because I started to encounter some rough edges that make Scala and T5 don't go together as smoothly as expected. Nevertheless, all problems were worked around.

This article is about how simply one can customized the output format of her URL in a RESTful way (see that for more details about REST, but whatever says this too academic article, we all well know that "REST" means "pretty shiny URLs" and "being 2.0, not like whose outdated web service" ;).

So, basically, what we will provide is two different ways of viewing an article:

A standard, HTML view with this kind of URLs: http://localhost:8080/blog/article/view/1

An XML or JSON output, with this kind of URLs: http://localhost:8080/blog/article/view:xml/1 or blog/article/view:json/1


<article title="First article" id="1">
    <published>true</published>
    <content>Content for the first article</content>
    <creationDate>2009-03-24 16:16:31.865 CET</creationDate>
</article>

And:


{"article": {
  "@published": "true",
  "@title": "First article",
  "@id": "1",
  "content": "Content for the first article",
  "creationDate": "2009-03-24 16:16:31.865 CET"
}}

The "view article" page

The first step here is to build a page that will show an article based on it's id.
We want that an URL like: http://localhost:8080/blog/article/view/1
Return the page:

For that, we add a ViewArticle class and ViewArticle template in the package "org.example.blog.pages.article".

The template is trivial, we simply display meaningful information of a backed article object:
org.example.blog.pages.article.ViewArticle.tml

<t:layout xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">

 <h2>${article.title}</h2>
 <h4>by ${authorname}, on ${article.creationDate}</h4>
 
 <div>
  ${article.content}
 </div>

</t:layout>

And that's all.

The Scala class is not much more complicated:
org.example.blog.pages.article.ViewArticle.scala

class ViewArticle {

  @Inject
  var articleDao : ReadDao[Article,String] = _

  @Inject
  var conf : BlogConfiguration = _
  
  @Property
  var article : Article = _
  
  var id : String = _
  
  def onActivate(id:String) { this.id = id }
  
  def getAuthorName() = this.conf.getAuthor.getLogin
  
  def setupRender {
    this.article = this.get(id)
  }

  private def get(id:String) = 
    if(null == id ) NoneArticle
    else this.articleDao.get(id).getOrElse(NoneArticle)
}

We see that I use two services, the Article DAO that allows to retrieve article from their store, and the blog's configuration that is used to display to author name: the article object it accessible from the template because of the @Property annotation (this T5 annotation is in fact the same as the Scala @BeanProperty one, it generates the pair of getter/setter for the attribute), getAuthorName() is called in the template by ${authorname}.

The logic of the page is almost inexistent: when the page is activated (what means an HTTP request is handled by that page), we store the "id" parameter (in our example, it's "1") for when the page is rendered. There is more about Tapestry 5 page activation and parameters here.
When the page is rendered, we ask the article DAO to retrieve the article with the given ID. If none is found, or if the given id was null (no parameter was found in the URL), we used a special "NoneArticle" object for the rendering. This object is a placeholder that stands for "null" for article type, and is defined as follow:

org.example.blog.data.Article.scala

object NoneArticle extends Article(None) {
  creationDate = new Date(0L);
  title = "No such article"
}

And with that, the HTML view is over.

Marshalling article

Here we deal with the transformation of article object into XML or Json, and how we make a service for that task available in our blog.

XStream, the swiss-knife of serialization

Well, in fact I will confess something: I did almost nothing to make the other two output renderings works, it's basically only the mapping of an XStream output to some Tapestry 5 event handlers.

If you don't already know XStream, stop reading here, and just go and look for its 2 minutes tutorial - it's actually a two minutes thing to read and shows how powerful Xstream is.

For the lazy clicker, there's a summary: XStream is an amazing XML and JSON marshalling and unmarshalling library for Java. It's fast, it's powerful, it's broadly used with all the good that that carries, and its learning curve is counted in seconds.

Basically, without any configuration, you can use it like that:


Person joe = new Person("Joe", "Walnes");
XStream xstream = new XStream();
String xml = xstream.toXML(joe);

And it will output something like that:

<org.foo.domain.person>
  <firstname>Joe</firstname>
  <lastname>Walnes</lastname>
</org.foo.domain.person>

With one more config line for the Xstream object:

xstream.alias("person", Person.class);

You get a prettier output:

<person>
  <firstname>Joe</firstname>
  <lastname>Walnes</lastname>
</person>

Doesn't it look simple? And if I say that it also works for JSON output, and also in the reverse way (from JSON/XML to Object), that output customization is almost infinite, you're likely to fall in love with this little, cute library.

Marshalling services for our blog

In the pages, we only need a simple service that transform object to a String representation. As always, we define an interface for that service:

org.example.blog.services.Marshaller.scala

trait Marshaller { 
   def to(o:Any) : String
}

Next, we are going to build two implementation for that service, one for XML output and one other for the JSON output. The two of them will extend a common Xstream based Marshaller:

org.example.blog.services.impl.XstreamMarshaller.scala

class XstreamMarshaller(val xstream:XStream) extends Marshaller  {
  override def to(o : Any) = this.xstream.toXML(o)
}

class XmlXstreamMarshaller() extends XstreamMarshaller(new XStream(new DomDriver()))

class JsonXstreamMarshaller() extends XstreamMarshaller(new XStream(new JsonHierarchicalStreamDriver()))

There is only one step remaining to enable the service in our blog: binding interface and implementation in the Tapestry module definition:
org.example.blog.services.AppModule.scala

object AppModule {
  //bind is a conventionnal method name for binding interface and implementation when no special configuration is needed
  def bind(binder : ServiceBinder) {
    binder.bind[Marshaller](classOf[Marshaller],classOf[impl.XmlXstreamMarshaller]) withId "xmlMarshaller"
    binder.bind[Marshaller](classOf[Marshaller],classOf[impl.JsonXstreamMarshaller]) withId "jsonMarshaller"
  }

Note that we assign a name (an Id) to each marshaller. That's because we now have two implementations for a given interface declared in the IoC registry. Tapestry 5 will not be able to know automatically what we really want to use when we will require a service injection for that interface, and so we will have to precise the name of the actual service we really want.

An now, let's use these marshallers to render JSONinfied and XMLified articles.

Binding URL to marshaller output

This second part aims to produce the correct output based on the URL.

T5 event handling system

Again, I did nothing special to bind URL and XML/JSON output since I used the standard Tapestry 5 event system: Url with ":" after a component or page name are interpreted as "component:eventname/eventparams".

For example, http://localhost:8080/blog/article/view:xml/1 means: throws the "xml" event on page "article", with the "1" parameter.

For our use case, the only thing to do is to handle "Xml" and "Json" events in the Scala back end of the "Article/View" page. Like most of the time in Tapestry 5, these event handlers are based on convention, and here the convention is to use "onEVENT" for the method name, where "EVENT" is the name of the event to handle.

The modified ViewArticle class looks like:

org.example.blog.pages.article.ViewArticle.scala

class ViewArticle {

  @Inject
  var articleDao : ReadDao[Article,String] = _

  @Inject
  var conf : BlogConfiguration = _
  
  @Inject @Service("xmlMarshaller")
  var xmlMarshaller : Marshaller = _
  
  @Inject @Service("jsonMarshaller")
  var jsonMarshaller : Marshaller = _

  @Property
  var article : Article = _
  
  var id : String = _
  
  def onActivate(id:String) { this.id = id }
  
  def getAuthorName() = this.conf.getAuthor.getLogin
  
  def setupRender {
    this.article = this.get(id)
  }
  
  def onXml = new TextStreamResponse("text/xml",this.xmlMarshaller.to(NoneArticle))
  def onJson = new TextStreamResponse("text/plain",this.jsonMarshaller.to(NoneArticle))
  
  def onXml(id:String) = {
    new TextStreamResponse("text/xml",this.xmlMarshaller.to(this.get(id)))
  }

  def onJson(id:String) = {
    new TextStreamResponse("text/plain",this.jsonMarshaller.to(this.get(id)))
  }
  
  private def get(id:String) = 
    if(null == id ) NoneArticle
    else this.articleDao.get(id).getOrElse(NoneArticle)
}

Compared to the first version, we just injected two marshallers and used them in event handlers. I set-up specific handlers for the case when no parameter is given in the URL.

Note that we solved the injection ambiguity problem on "Marshaller" injection by naming the service we really want to be injected thanks to the "@Service("name")" annotation after the @Inject one.

The only other remarkable thing is the TextStreamResponse object, that allows to return arbitrary text output for rendering. It's an implementation of the StreamResponse interface, that allows to return arbitrary content - yes, returning a PDF for a given URL is a matter of returning the correct StreamResponse in a handler method. Simple, no ?

With that, we have a first promising result.

http://localhost:8080/blog/article/view:xml/1 leads to:

<org.example.blog.data.Article>
  <published>true</published>
  <comments class="scala.Nil$"/>
  <content>Content for the first article</content>
  <title>First article</title>
  <creationDate>2009-03-25 14:19:41.940 CET</creationDate>
  <id class="scala.Some">
    <x class="string">1</x>
  </id>
</org.example.blog.data.Article>

And http://localhost:8080/blog/article/view:json/1 leads to:

{"org.example.blog.data.Article": {
  "published": true,
  "comments": {
    "@class": "scala.Nil$"
  },
  "content": "Content for the first article",
  "title": "First article",
  "creationDate": "2009-03-25 14:19:41.940 CET",
  "id": {
    "@class": "scala.Some",
    "x": {
      "@class": "string",
      "$": "1"
    }
  }
}}

And non existing article or no parameter, like in http://localhost:8080/blog/article/view:xml/foobar leads to:

<org.example.blog.data.NoneArticle_->
  <published>false</published>
  <comments class="scala.Nil$"/>
  <content/>
  <title>No such article</title>
  <creationDate>1970-01-01 01:00:00.0 CET</creationDate>
  <id class="scala.None$"/>
</org.example.blog.data.NoneArticle_->

That's not too bad for a couple of line of code, but output should be nicer.

Configuring output

Actually, we don't want to show the qualified class name in the output, nor we need the comments here, and it will be cool to have "id" and "title" as attributes of the "article" node.

For that, we will customized Xstream marshaller.

The first step is to change the marshaller implementation registration in AppModule to a more configurable one:

org.example.blog.services.AppModule.scala

  def bind(binder : ServiceBinder) {
    //remove marshaller from here
  }

  def buildXmlMarshaller(): Marshaller = {
    val m = new XmlXstreamMarshaller
    ConfigureArticle4Xstream.configure(m.xstream)
    m
  }

  def buildJsonMarshaller(): Marshaller = {
    val m = new JsonXstreamMarshaller
    ConfigureArticle4Xstream.configure(m.xstream)
    m
  }

These new definition also build two marshallers, named "XmlMarshaller" and "JsonMarshaller", but with that way we are able to configure the Xstream instance of each implementation.
Since our case is really simple, the two configurations are the same, and look like that:

org.example.blog.services.impl.XstreamMarshaller.scala

object ConfigureArticle4Xstream {
  def configure(x:XStream) {
    import org.example.blog.data.{Article,NoneArticle}
    //output "article" in place of org.example.blog.data.Article
    x.alias("article",classOf[Article])
    
    //title and id will be output as attributes of article...
    x.useAttributeFor(classOf[Article],"title")
    x.useAttributeFor(classOf[Article],"id")

    //...and since Id is not a simple string, we have to provide a converter to make it works
    x.registerLocalConverter(classOf[Article],"id",new ArticleIdConverter())
    
    //we don't want to display comments
    x.omitField(classOf[Article],"comments")
    
    //special config for NoneArticle
    x.alias("article",NoneArticle.getClass)
  }
}

Each line provides the commented explanation.
The id converter simply output the id if available, or "none":
org.example.blog.services.impl.XstreamMarshaller.scala

class ArticleIdConverter extends SingleValueConverter {
  def fromString(s:String) = if("none" == s) None else Some(s)
  def toString(a:Object) = a match { 
    case None => "none" 
    case Some(x) => x.toString 
    case _ => error("Not supported type: " + a.getClass.getName)
  }
  def canConvert(c:Class[_]) = {
    if(c == classOf[scala.Option[_]]) true
    else false
  }  
}

With this configuration, outputs are much nicer:

http://localhost:8080/blog/article/view:xml/1 leads to:

<article title="First article" id="1">
  <published>true</published>
  <content>Content for the first article</content>
  <creationDate>2009-03-25 15:09:20.476 CET</creationDate>
</article>

And http://localhost:8080/blog/article/view:json/1 leads to:

{"article": {
  "@title": "First article",
  "@id": "1",
  "published": true,
  "content": "Content for the first article",
  "creationDate": "2009-03-25 15:09:20.476 CET"
}}

And non existing article or no parameter, like in http://localhost:8080/blog/article/view:xml/foobar leads to:

{"article": {
  "@title": "No such article",
  "@id": "none",
  "published": false,
  "content": "",
  "creationDate": "1970-01-01 01:00:00.0 CET"
}}

Now, we can say too our chief that he can go and look for investor, our blog has the REST (well, almost ;).
And that's all for today !

Next time

We reach a rather satisfying result with really few lines of code, but I have to say that our implementation is bad.

The main reason for that is that there is a bunch of coupling and code duplication at the moment:
- from the page designer point of vue, it's crappy to have to inject several marshallers, and choose the correct one for each event;
- moreover, addind a new output (for example, plain text) would mean modifying *all* pages that use marshallers;
- with the actual configuration, each time that we want to customize an output for a given object, we have to actually modify the code of XstreamMarshaller core implementation, or in the core module definition !

So the next time, we will see how we can improve these points. And again, it will be easy, thanks to Tapestry IoC provided features.

As always, the real full code is available at Github at this tag :
http://github.com/fanf/scala-t5-blog/tree/article4_20090325

Java annotation, scala object and javassist don't get along well

2009-03-16T10:18:00.006+01:00

[Update: in the next paragraph, "showstopper" is clearly too strong - put it in my bad english level. The title is perhaps better, I wanted to say that things didn't came along as well as I hoped initially. In no case I wanted to sound over-pessimistic. Actually, the workaround is rather simple : I can use a direct call to the look-up service of T5 IOC each time I need a named service in place of the direct injection of that service.]

In my quest of using Tapestry 5 with a Scala back-end, I believe I fall on a showstopper. I seems that Javassist doesn't see annotation on method parameter in Scala object, although the annotation (being marked with Runtime retention) is seen with the Java reflexion API.

I tested with both Scala 2.7.3 and 2.8.0-nigtly, and both Javassist 3.9.0.GA and 3.10 - the behaviour is consistent in all combinations.

In fact, what seems to happens is that when one defines a Scala object "Foo.scala", scalac generates two classes : "Foo.class" that is a kind of singleton facade and initializer, and "Foo$.class" that is the actual class.

When the java reflexion API is used, I think that scala delegates the call in the rigth way. The problem seems to be that Javassist directly read the bytecode of "Foo.class", and doesn't see the annotation - it seems to be only on the method in "Foo$.class".

You can you see this behaviour like that:

Make a simple Java annotation, and compile it, something like @InjectService in Tapestry5-annotation package:


@Target({PARAMETER, FIELD})
@Retention(RUNTIME)
@Documented
public @interface InjectService
{
    String value();
}

Create a scala class that make use of that annotation and test it visibility thanks to Java reflexion API and Javassist :


import org.apache.tapestry5.ioc.annotations.InjectService
import javassist._
import javassist.runtime._


object ObjectTestAnnotation {
  def methodWithParamAnnot(@InjectService("service id") s:String) = s
}

class ClassTestAnnotation {
  def methodWithParamAnnot(@InjectService("service id") s:String) = s  
}

object Main {

  def main(args: Array[String]) { 
    /*
     * Using Java reflexion API
     */
    val methodWithParamAnnot = ObjectTestAnnotation.
      getClass.getMethod("methodWithParamAnnot", classOf[String])
    val annotations = methodWithParamAnnot.getParameterAnnotations
    println("* with java reflexion API, on ObjectTestAnnotation")
    annotations.foreach(_.foreach( x => println(x)))
    // print:
    // * with java reflexion API, on ObjectTestAnnotation
    // @org.apache.tapestry5.ioc.annotations.InjectService(value=service id)

    val methodWithParamAnnot1 = classOf[ClassTestAnnotation].
      getMethod("methodWithParamAnnot", classOf[String])
    val annotations1 = methodWithParamAnnot1.getParameterAnnotations
    println("* with java reflexion API, on ClassTestAnnotation")
    annotations1.foreach(_.foreach( x => println(x)))
    // print:
    // * with java reflexion API, on ClassTestAnnotation
    // @org.apache.tapestry5.ioc.annotations.InjectService(value=service id)

    /*
     * Using Javassist
     */
    val cp = ClassPool.getDefault()
    val ctString = cp.get("java.lang.String")
    val methodWithParamAnnot2  = cp.get("test.ObjectTestAnnotation")
      .getDeclaredMethod("methodWithParamAnnot",Array(ctString))
    val annotations2 =  methodWithParamAnnot2.getParameterAnnotations
    println("* with javassist, on ObjectTestAnnotation")
    annotations2.foreach(_.foreach( x => println(x)))

    // print (AND THAT'S BAD, the annotation is not seen !)
    
    // * with javassist, on ObjectTestAnnotation
      
    val methodWithParamAnnot2_bis  = cp.get("test.ObjectTestAnnotation$")
      .getDeclaredMethod("methodWithParamAnnot",Array(ctString))
    val annotations2_bis =  methodWithParamAnnot2_bis.getParameterAnnotations
    println("* with javassist, on ObjectTestAnnotation$")
    annotations2_bis.foreach(_.foreach( x => println(x)))
    // print:
    // * with javassist, on ObjectTestAnnotation$
    // @org.apache.tapestry5.ioc.annotations.InjectService(value="service id")
    
  
    val methodWithParamAnnot3  = cp.get("test.ClassTestAnnotation")
      .getDeclaredMethod("methodWithParamAnnot",Array(ctString))
    val annotations3 =  methodWithParamAnnot3.getParameterAnnotations
    println("* with javassist, on ClassTestAnnotation")
    annotations3.foreach(_.foreach( x => println(x)))
    // print:
    // * with javassist, on ClassTestAnnotation
    // @org.apache.tapestry5.ioc.annotations.InjectService(value="service id")
    
    println("done")
    
    
  } 
  
}

Cry ! Because, of course, Tapestry 5 uses these annotations in such a way that a bug here make the whole thing unusable - the core of T5-IOC container relies on them.
I would have to see if I can use a class in place of the object...

Small UTF-8 URL

2009-03-03T10:51:00.003+01:00

I just found this site thanks to reddit : http://www.reddit.com/r/programming/comments/81ld2/tinyarrows_what_do_you_think_site_we_made_to/

The goal is to build tiny URL from long ones, something as old as the Internet. The difference is that the URL can be build with UTF-8, what gives you funny opportunities :)

So now, you can access my blog with these URL :

http://➡.ws/φ
http://➡.ws/φ42

Ok, that's something a little useless, but it's cool and funny :)

Personal thougth: Scala, Haskell, Coq and so little time !

2009-02-15T21:01:00.007+01:00

There is a lot of really cool stuff going on the world in computer science and more precisely in formal proof, the last I found being: this article about "A Monadic, Functional Implementation of Real Numbers"

Haskell is continuously gaining attention, Scala and Clojure bring new dimensions to the JVM, this later (hopefully) evolving towards better support for functional paradigm and perhaps more verification support.

I'm lucky enough to have already worked in formal proof with the CompCert team when I graduated... but it was 5 years in the past.

In the meantime, I worked in the "real life business", and now I'm sure this don't feat to me. Well, at least I worked in the security domain, and discovered that their is some really hight level work done in this domain in France: two years ago, Gemalto proved a never reached level of certification for the JavaCard plateform:
http://www.gemalto.com/php/pr_view.php?id=239 . And they did it with Coq, what a coincidence :)

Well, I really want to spend a lot of more time in all these fields. So much things to do, so little time to spend in them...

EDIT: I forgot all the cool things around parallelism, Pi-Calculus, or actors (I believe there is something great that is on the way with Scala actors ;).

Tapestry 5 - Scala : start of delusion

2009-02-12T11:48:00.003+01:00

I didn't write anything for a long time on my Tapestry 5 / Scala experiment. Things are starting to go wrong.

From one part, I found what may have been a bug in Scala ( https://lampsvn.epfl.ch/trac/scala/ticket/1695 ) and that delayed me lot in the use of T5 IoC binder.

For the other part, T5 IoC does not seems to support parameterized types at more than one level, and so I can't use parameterized class in contributions.

For example, I can't contribute Tuple, or (and that's quite a big limitation) class because in Scala, you can't use the unparameterized "Class" argument, it must be "Class[Something]", and here lies the hell of generics...

So for now, I'm beginning to thing that T5 and Scala don't feet so well together, or at least that I have some nuts to scratch and some "best practices" to find before going further in the test.

EDIT: as proposed by Ricky Clarkson, for the class problem, just use Class[_]

Ivy 2.0 released

2009-01-26T11:44:00.003+01:00

The java library dependency management system Ivy finally reached the 2.0.0 released, and that's a great new.

The release note is here:
http://ant.apache.org/ivy/history/2.0.0/release-notes.html

(for the lazy clicker, here is the announcement part of the release note:)


Jan 20, 2009 - The Ivy project is pleased to announce its 2.0.0 release.
This is the first non-beta release of Ivy under Apache.

Ivy is a tool for managing (recording, tracking, resolving and
reporting) project dependencies, characterized by flexibility,
configurability, and tight integration with Apache Ant.

Key features of the 2.0.0 release are
* enhanced Maven2 compatibility, with several bug fixes and more
  pom features covered
* improved cache management, including dynamic revision caching
  with fine grain TTL
* improved concurrency support with cache locking and atomic publish
* namespace aware validation, allowing to use validation with
  extra attributes
* new 'packager' resolver added
* better and more homogeneous relative paths handling
* better support for local builds
* numerous bug fixes as documented in Jira and in the release notes

We encourage all users of Ivy to update to this new version.

Issues should be reported to:
https://issues.apache.org/jira/browse/IVY

Download the 2.0.0 release at:
http://ant.apache.org/ivy/download.cgi

More information can be found on the Ivy website:
http://ant.apache.org/ivy/

Regards,
Maarten Coene

Note: I'm in now way implied in the Ivy dev-team, I just love their tool and wanted to thanks them for it.

Ivy seems to be loved by new "build system" make. Gradle, the Groovy buildr, is based on Ivy.
I will also signal the on-going work around an "maven-style build system with a stack of convention" build on top of Ivy and Ant, easy-ant (and there is an irc chan on freenode: #easyant). The project is work-in-progress, but a lot has already been done, and I believe it will be a great solution for all of us that are pissed-off by Maven, or just can't move from Ant but want to normalized (or "base on conventions") their build scripts, and integrate Ivy.

Note 2: I'm neither implied in easy-ant dev ;)

So, it seems that Maven is not the final winner in Java build system land, and that's good (no monopole, concurrency for the best...) !

Update: I simply forgot to link to Xavier Henin blog post about Ivy 2.0.0 release. Shame on me :/

Tapestry 5 - Scala : a layout and basic CRUD for the blog

2009-01-19T07:01:00.017+01:00

After setting up a hello world application in Scala and Tapestry, and testing how Tapestry IoC / property access works in this environment, it's time to actually do something.

So, this article will explain how I set up the basic fonctionnalities for our blog:

build a "Layout" component, so that the development will hurt our eyes a little less;
add an Article object, and the standards pages to use it:
- the "home page" page will show all the published articles;
- a "create" page will allow to add new article;
- a "view" page will show only one article and its comments
- a "manage" page will allows to view a list of all the article with some actions, like publish, delete, edit.

Index

Setting up a layout
Create, Retrieve, Update, Detele articles

The "Article" domain object
Data access object

Generic DAO API
In memory Article DAO
Enable Article DAO service thanks to T5 IoC

Putting the parts together : the presentation layer

The Home page
Create new articles
Manage all articles

Final words

Conclusion
Source code

Setting up a layout

Using "layout" is a common pattern to apply the same design for all the site. In tapestry, no need to use an external template engine like sitemesh, you can simply build a "layout component" that you will use on all page that have to be decorated.

This pattern is so common that Tapestry 5 has a documentation page on how to do it with T5, so you just have to follow it : the harder part is to design the layout, or if, like me, you are a dumb in design, find a cool CSS/HTML template on internet (thank you Free CSS Templates for the one I chose.

As it's the first time that we will build a Tapestry 5 component, I will details a little what we need. In Tapestry 5, component are simple POJOs. They go under the ${t5-root}/components package, and are coupled with a Template (.tml) file.

create the ${root}/components/Layout.tml and ${root}/components/Layout.java couple of files for our component;
add the needed CSS/images in the webapp directory.

The code for the layout is here:


@IncludeStylesheet(Array("context:css/red/style.css"))
class Layout {

  @Inject @Property
  var conf : BlogConfiguration = _
  
}

The interesting part is the @IncludeStyleSheet annotation, that say to T5 ti add it the given CSS into the header of the pages where this component is used, what is handy for a layout component.

We can see that in Scala, we can't simply use the

@IncludeStylesheet({"context:css/red/style.css"})

notation, and have to explicitly build a new array - hopefully, it's trivial in Scala.

The template part of the component is bigger, since it's there that goes all the common HTML declaration.


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">
<head>
 <title>${conf.blogTitle}</title>
 <meta http-equiv="Content-Language" content="English" />
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>

 <div id="wrap">

  <div id="header">
   <h1><a t:type="pagelink" t:page="index">${conf.blogTitle}</a></h1>
   <h2>${conf.blogDescription}</h2>
  </div>
 
  <div id="menu">
   <ul>
    <li><a t:type="pagelink" t:page="index">Home</a></li>
[...]
   </ul>
  </div>
  
  <div id="content">
   <div class="left"> 
    
    <t:body />
   
   </div>
  
   <div class="right"> 
   
    <h2>Archives</h2>
    <ul>
[... here will go the archives ...]
    </ul>
    
    <h2>Tags :</h2>
    <ul>
[... here will go tags link ...]
    </ul>
    
   </div>
  
   <div style="clear: both;"> </div>
  
  </div>
  
  <div id="bottom"> </div>
  <div id="footer">
   Designed by <a href="http://www.free-css-templates.com/">Free CSS Templates</a>
  </div>
 </div>
</body>
</html>

The important part it the <t:body /> tag, that says "here will go what will be find between the <t:layout> and </t:layout> tags. So, in the page where we want to use this layout, we will use template code like:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<t:layout xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">
  <h2>New article</h2>
  [....]

</t:layout>

And now, our blog is prettier:

Note: I equally use <htmlTag t:type="T5_component"...> and <t:="T5_component"> notation to include T5 component in templates. The first one is better for designer, as template preview is correct, the second one is a little shorter. They are equivalent, and I should homogeneously use one or the other...

Article's CRUD

All this blog application is a pretext for that very part, so let's take a look at it. Reminder: "CRUD" stands for "Create, Retrieve, Update, Delete", and is a well know acronym that is used for simple application, with very little domain logic, and which are almost a front-end for datas, persisted in some layer (MySQL comes to mind, but CouchDB is a better buzz word today ;)

To sum-up, we have Article objects, a DAO to persist them, and a couple of pages to enable human I/O.

The "Article" domain object

An article is an object with an id, a title, a content, a list of comments and a creation date.

The "id" is unique identifier for an article among all the blog's article. Most of the time, it will be used to identity a particular article in the persistence layer or in URL.
I take the choice to let the persistance layer assigned the id, because we really are in a CRUD application, and no business logic can provide a realiable unique identifier. That means that a not yet persisted article has no id. In the same time, I want to enforce the fact that Id are imutable datas, that given a Article object, the id won't ever change.

In java, this kind of requirement can't easily be done in an other way than usgin "null". In Scala as in many other language, we have an Option type that has two kind of value:

the "None" value, which means "there is no data here";
the "Some[TypeOfData]" value, which means "there is a data here, and that is it's value".

I use this type for the article "Id", and the "Id" is a constructor param value of article, so that:

article id is immutable: an living object can't have it's id change;
an article with "None" id has never been saved ;

the persistence layer will assign IDs and return article with there definitive ID

Given that, that's the code for the Article object:

org.example.blog.data.Article.scala


class Article(val id:Option[String]) {
  /*
   * "none" is not allowed for article ID
   */
  assert( id.forall( (s:String)=> !(s.toLowerCase == "none" ))) 
  
  @BeanProperty var creationDate = new Date()
  
  @BeanProperty var title = ""
  
  @BeanProperty var content = ""
  
  @BeanProperty var comments = List[Comment]()
  

  @BeanProperty var published = false
  
  def getId = id
  
  /*
   * String translation of the ID. Of course, it 
   * requires that id can't be the "None" String, 
   * and that's why we add the "assert" requirement
   */
  def getDisplayId = this.id.getOrElse("None") 
}

object Article {
  
  /*
   * Create a copy Article from a source one, 
   * setting the ID to a new value.
   */
  def apply(id:String, source:Article) : Article = {
    val a = new Article(Some(id))
    a.title = source.title
    a.content = source.content
    a.comments = source.comments
    a.creationDate = source.creationDate
    a.published = source.published
    a
  } 
}

Apart from the Article constructor and "Id" type explained before, there is three other notable things in this class:

A getDisplayId that is a simple method to give the article Id to other layer, especially the presentation layer. I chose to map "Some(id)" to the given id string, and the "None" type to the "None" string, what implies that I should never accept the "None" id;
since I can't accept "None" string as id, I added a requirement through an assertion (and no, performances don't matter, it's a tool blog application ;)
finally, there is a strange "object" definition after my class with the same name as it, that needs its own paragraph

"objects" are the Scala way to define static methods and contents, and it's why I used the "object" key word in the AppModule.
When paired with a class, it is called a companion object for the class. They have some special rights, in particular regarding visibilyity, that goes beyond this article.

I used this one to create a "copy" method that allows to create an article with a given id, different from the source - remember, I want to have immutable ids for an Article for all is life in memory.

The question is "why do I called this method apply, what is a name that carry almost zero information ?". Simply because it's a Scala magic word, that can be zapped when used ! Just writing "Article(id, article)" will call Article.apply(...). If you remember the "Array" in the @IncludeStyleSheet for the layout... That was the same principle. Array is the companion object of the Array class, and "Array("...","...")" secretly call the "apply" method of Array that take a list of String as parameter.

And we are done with Articles.

DAO

A DAOs ("Data Access Objects") are objects responsible for accessing and persisting (or delegate persistence of) other objects. They are the heart of CRUD application.

The first paragraph explain our generic DAO API, the second will show a naive, in memory implementation of the generic DAO for article, and a third one will explain how to use it with Tapestry IoC.

Generic DAO API

We will define DAO by their API, the set of method exposed by these service objects. In Java, API means "Interfaces", in Scala they means "Traits". In our example, they are the same things. We will define a real implementation

org.example.blog.services.DAO.scala


/**
 * A read-only dao
 * @param T is the type of entities handled by this DAO
 * @param K is the type of the key that is used to identify entities.
 */
trait ReadDao[T, K <: Serializable] {
  
  /*
   * Retrieve an entity from its key. If no
   * entities are known for the given key, None is returned.
   * @param K the unique id of the entity to fetch
   * @return None if no entity match that key,
   *         Some[entity] else
   */
  def get(id:K) : Option[T]

  /**
   * Retrieve all the entities known by that DAO.
   * Be carefull, that may be a huge number.
   * @return the list of all entities for that DAO
   */
  def getAll() : List[T]
 
  /**
   * Find all the entities that match the given requirement
   * @param T => Boolean : the function to apply to find if
   *        an entity should be included in the returned list.
   *        (on a "true" return) or excluded (on a "false" return)
   * @return the list of enetities matching the filter.
   */
  def find(filter: T => Boolean) : List[T]
}

/**
 * A write-only dao
 * @param T is the type of entities handled by this DAO
 * @param K is the type of the key that is used to identify entities.
 */
trait WriteDao[T, K <: Serializable] {
  
  /**
   * Persist the given entity: create a new one if
   * the entity wasn't know in that DAO (entity
   * key was None), or update an existing entity 
   * (it's key was Some[K]).
   * @param T the entity to persist
   * @return the key of the persisted entity if the process 
   *         succeded, or None the the peristence failed.
   */
  def save(entity:T) : Option[K]
  
  /**
   * Delete the article matching this id. 
   * If no article match this id, does nothing.
   * Return true is the deletion is successful
   */
  def delete(id:K) : Boolean

}

/**
 * A read-write DAO, that combine read and write DAO traits.
 */
trait ReadWriteDao[T, K <: Serializable] extends ReadDao[T,K] with WriteDao[T,K]

Comments speak for themselves here, and "Option" is well-known now.
The only surprises are the "<:" which means that the K type has to be Serializable, and more notably for a Java guy, the "find" method: it takes a method as parameter !
The signature of the filter method is "I take an entity of type T as parameter, and return a Boolean".

For example, if we take an Article DAO, we may use this to find all the article whose title begin with "The" like that:


val articles = dao.find( (a:Article) => a.title.startsWith("The") == true )

That's all. It means "the method find takes as parameter a method that take an article as parameter, and return the result of the evaluation of "a.title.startsWith("The") == true".

It can even be simpler, because Scala allows to use "_" as a place-holder for parameter when there is no ambiguities, like here (in our case, find can't take anything but a method which has the "Article => Boolean" signature):


val articles = dao.find( _.title.startsWith("The") == true )

If you don't see why "closure" are so useful, look how simple that declaration is compared to the burden to declare a filter interface and used it, even with anonymous class in place of real instances...

In memory Article DAO

Now that we have our generic DAO API, we are ready to implement a version for Articles. This first DAO will be a really simple one, where articles are persisted in memory (in a Map).

org.example.blog.services.impl.dao.InmemoryDao.scala


import org.example.blog.data.Article
import scala.collection.mutable

import org.example.blog.services.ReadWriteDao

/**
 * A simple, naive implementation of the Article DAO.
 * In particular, this implementation is
 * NOT AT ALL THREADSAFE
 */
class InmemoryArticleDao extends ReadWriteDao[Article, String] {
  
  private val memory : mutable.Map[String, Article] = new mutable.HashMap()
  private var id = 0
  private def newId = { id = id + 1 ; id }
  
  def get(id:String) = this.memory.get(id)

  def getAll() = this.memory.values.toList
 
  def find(filter: Article => Boolean) = 
    (for { 
      a <- this.memory.values
      if(filter(a))
    } yield a).toList

  def save(article:Article) = {
    val a = article.id match {
      case None => 
        val i = this.newId
        Article(i.toString,article)
      case Some(id) => article
    }
    assert(a.id.isDefined)
    this.memory.put(a.id.get,a)
    //check if article is in map for the id, return id if OK
    this.memory.get(a.id.get).map( _.id.get)
  }
  
  def delete(id:String) = !( (this.memory - id).isDefinedAt(id) )
}

We can see that the "extends ReadWriteDao[Article, String]" is really like Java with generics.

The implementation is a basic mapping between our DAO API and the Map used as a back-end. Article Ids are generated by an incrementing number, but there's no lock against thread concurrency. Say that for now, it's really a tool example, and all in all, our blog can have only one author (reminds the configuration object of the previous post).

The save method is the most complex, because we have to process the update and the create case, based on the fact that id is None or Some(value).
We also see the use of the Article companion object "apply", that allows to copy the given article to a new one, but with it's freshly created id.

The filter method the Scala for comprehension loop that automatically concatenates yielded elements, but it could have been done with an even more imperative "for" loop too:


def find(filter: Article => Boolean) = {
    var articles = List[Article]()
    for(a <- this.memory.values) {
      if(filter(a)) articles = a :: articles 
    }
    articles
}

I believe that the first method is better, because the two are almost as inefficient, and the latter use a mutable variable.

That's all for the implementation of our DAO !

Enable Article DAO service thanks to T5 IoC

Now that we have a DAO API, and a DAO implementation for Article, we want to let our application know that when we use a DAO on articles, what we really want is to use the "In Memory Article DAO".

As for the Configuration service on the previous post, we just have to add a "build" method into the AppModule object to bind the ReadWrite[String,Article] DAO to its implementation:


  def buildArticleDao = new InmemoryArticleDao()

Hum. Yeah, there is nothing to do but that, but as we are Professional, we can't let our bosses think that our job is so simple, so let's add some boilerplate to make the code seems harder, more complex:


  def buildArticleDao = {
    val a1 = new Article(None)
    a1.title = "First article"
    a1.content = "Content for the first article"
    a1.published = true
    
    val a2 = new Article(None)
    a2.title = "Second article"
    a2.content = "Content for the second article"
    
    val m = new InmemoryArticleDao()
    m.save(a1)
    m.save(a2)
    m
  }

OK, that's better ! Actually, I just initialized the DAO with two articles (one published, not the other one), but it's far more impressive like that ;)

Putting the parts together : the presentation layer

Now that we (finally !) have all the services to create and retrieve articles set-up, we can switch to the only part in which customers have some interests, the presentation layer (that's because code screenshots look bad on powerpoint).

The Index page

The first page that will use our new services is the home page. On this page, we just want to display all published articles.

For that, we will use the Loop component:

org.example.blog.pages.Index.tml


<t:layout xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">

 <div t:type="loop" t:source="articles" t:value="article" class="article">
  <h2><a t:type="pagelink" t:page="article/view" t:context="article.displayid">
   ${article.title}
  </a></h2>
  
  <div>${article.content}</div>
 </div>
 
</t:layout>

We see in this template that we link to the "article/view" page, in which we will display the article with its comments. But as it's for an other day, for now we just create a org.example.blog.page.article.ViewArticle.{scala,tml} couple so that Tapestry 5 don't stop on a broken link (it validate that all lins are correct at start time), and we will take care of them the next time.

We also see that we need a "source" from where articles are taken, and a "value" to hold the current article of the loop. Of course, these objects are provided by the Scala part of the couple:

org.example.blog.pages.Index.scala


class Index {
  
  @Inject
  var readArticleDao : ReadDao[Article, String] = _
  
  @Cached
  def getArticles = readArticleDao.find( _.published == true ).toArray
  
  @Property
  var article : Article = _
  
}

The code stands for itself : we inject a read-only DAO for article - we don't need more, and even if actually we get the in memory read write implementation, this code only care for the read part ; we have a "getArticles" method that retrieve all publish articles from the DAO (remember: closures are great), and we have an Article "@Property" annotated to receive the current article from the loop.

As we have initialized the DAO with two articles (one published among them), as soon as we start the application, we can see the first, published article on the home page:

Isn't that great ?

Create new articles

Now that we can see our article, we may want to add some new ones - well, it's aim to be a blog, and what the point if I can't talk about how cute is my ickle hamster ?

For that, let's build the "create article" page.
Let's begin with the template. In this first version, I won't rely on the magc BeanEditForm, and we need to be able to set a title, a content, and choose to publish or not the article:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<t:layout xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">
 <h2>Create a new article</h2>

 <t:form t:id="NewArticleForm" class="new-article">
    
  <p>
   <t:label for="publish" />&nbsp;<t:checkbox t:id="publish" t:value="article.published" />
  </p>
  
  <p>
   <t:label for="title"/><br/>
   <t:textfield class="large" t:id="title" value="article.title" validate="required"/>
  </p>
  
  <p>
   <t:label for="content" /><br/>
   <t:textarea class="large" t:id="content" value="article.content" />
  </p>
  <t:submit />
 </t:form>
</t:layout>

This template is a little boring, but it's the first time we see a constructed form and it's different input. The title is required, and the form will be refused as long as it is no provided. There is other predifined validator, like min/man, regexp... And... well, there's nothing more to say : all input has a value parameter that is the link to the server-side java^W Scala object that will handle it, and there is a submit button. And that's all.

That looks like that:

Ok, so how do we handle that on the server side ?

org.example.blog.page.article.CreateArticle.scala


import org.apache.tapestry5.annotations.{Property,Persist,InjectPage}
import org.apache.tapestry5.ioc.annotations.Inject

import org.example.blog.data.Article
import org.example.blog.services.WriteDao
 
import java.text.DateFormat

class CreateArticle {

  @Inject
  var articleDao : WriteDao[Article,String] = _
  
  @Persist @Property
  var article : Article = _

    
  @InjectPage
  var redirectPage : ManageArticle = _
  
  def setupRender {
    if(null == this.article) {
      this.article = new Article(None)
    } 
  }
  
  def onSuccessFromNewArticleForm = {
    articleDao.save(article) match {
      case None => error("Dao error ! Please retry.")
      case _ => this.article = null ; redirectPage
    }
  }
}

This time we need the "Write" part of the DAO (and a again, no need for the other, so I injected the minimal aspect), and an Article that will back the the new article.

The article is annotated @Persist, so that it will be stored in session. We need that because the form has to be validated, and perhaps show again: we don't want to loose what was written in this case.

The setupRender method is a conventional name that matches a component rendering phase. We will take advantage of this method to initialized a new Article, if needed.

The onSuccessFromNewArticleForm is again a conventional method name to handle a component event. On that case, the event is "success", and we await it from the "articleForm" component... which is our form's "t:id". So, you get it, when the form succeed, we go into that method, in which we try to save the Article. If the DAO failed in its job, we raise an error, and else we redirect into the ManageArticle page. There is a lot of way to redirect to a page in T5: you can use URL, page class, the string page name, or the InjectPage annotated page. This method is handy when you need to init some value in the page before redirecting to it. Well, here it's just because it's cool ;).

And now, we are redirected to the "manate" page.

Manage all articles

The goal of this page is to give the author the possibility to view the list of all existing articles. Moreover, we want to be able to go there detail page, to publish or unpublish, edit and delete them.

In this case, the perfect component is the grid component.

This component allows to display a list of beans, one column by property, and allows to add, remove, reorder columns.

The template looks like that:


<t:layout xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">

 <h2>List, modify, publish article</h2>
 
 <t:grid source="articles" row="article"
   reorder="title" exclude="content" add="comments,publish,edit,delete">
  
  <t:parameter name="titleCell">
   <t:pagelink t:page="article/view" t:context="article.displayid">
    ${article.title}
   </t:pagelink>
  </t:parameter>

  <t:parameter name="publishCell">
   <t:actionlink t:id="changePublication" t:context="article.displayid">
    ${changePublication}
   </t:actionlink>
  </t:parameter>

  <t:parameter name="commentsCell">
   ${article.comments.size()}
  </t:parameter>
 
  <t:parameter name="editCell">
   <t:pagelink t:page="article/edit" t:context="article.displayid">
    edit
   </t:pagelink>
  </t:parameter>
  
  <t:parameter name="deleteCell">
   <t:actionlink t:id="delete" t:context="article.displayid">
    delete
   </t:actionlink>
  </t:parameter>

 </t:grid>
</t:layout>

What looks in real like:

There is some interesting things in this template:

we have a source of bean, and the current Article is handle in the "row" parameter;
the "t:parameter" is special invocation that allows to bind a block of template code to component parameter. In our case, each t:parameter is used to replace the content of a column cell;
the pagelink component has already been seen several times, but here can see how easy it is to map page to URL: it's simply the list of directories from the "pages" package to the page object. We also see how we can pass a some context (variable) into the targeted page;
lastly, the "t:actionlink" is a component that allows to fire an event on the server side;

So, how we handle all that on the server side ?

org.example.blog.pages.article.ManageArticle.scala


class ManageArticle {
  
  @Inject
  var rwDao : ReadWriteDao[Article, String] = _
  
  @Property
  var article : Article = _
  
  def getArticles = this.rwDao.getAll.sort( _.creationDate.getTime > _.creationDate.getTime ).toArray
  
  def getChangePublication = if(article.published) "Un-published" else "Published"
  
  def onActionFromChangePublication(id:String) {
    val a = this.rwDao.get(id).getOrElse(error("No such article, id: " + id) )
    a.published = !a.published
    this.rwDao.save(a)
  }
  
  def onActionFromDelete(id:String) {
    if(!this.rwDao.delete(id)) {
      error("Can not delete this article")
    }
  }  
}

The code is fairly simple and clear:

we need the ReadWriteDao, so we inject it;
we need an article to keep the current row, so we add an @Property annotated Article;
the source of all bean is provided by the "getArticles()" method, that simply retrieve all the articles from DAO (and sort them by date);
the "getChangePublication()" return the good text given the status of the article;
the "onActionFromChangePublication" method handle the event from the actionLink with "t:id" changePublication. The method await a parameter which is given by the context of action link (and is the article id). We react at this event by changing the status of the matching article, and save it back into the DAO;
finally, the "onActionFromDelete" handle the event from the "delete" link, and react to it by deleting the article from the DAO.

Note that all event handler that does not return anything redirect to the calling page.

Final words

Conclusion

And that's done ! The goal perimeter is reached, we can see, add, manage articles in a not too ugly blog.

Now, a lot of things remained:

Articles are not really persisted, and are lost on server shutdown. What abot saving them into a database, or even better into a more "text oriented" storage, has XML files, or something like a Java Content Repository (or a CouchDB ?)
Where are the comments ?
And the article details ? And all the formating of articles is lost in rendering ! That's awful ! Perhaps we need a smarter rendering component... and so we may used it at several place around the site (Index, article details...)
And what about a better text editor, that allows some kind of rich UI ? Personally, I really like showdown editor
And tags, hu ? We are building the tomorrow blog plateform for web 3.0 and don't even have tags ? That can't be serious !
oups, somebody just pointed that for now, there is no way to protect the manager area from the simple user... No authentication, no authorizations...
I also said that I will attempt to use easy-ant as build tool, in place of maven
and the list is almost infinite !

So, there is still some room to a little more experiment with T5 and Scala !

Source code

As always, the source code is available on the GitHub repository of the project.

To download and test the code for that articles, simply executes these commands:


% git clone git://github.com/fanf/scala-t5-blog.git
% cd scala-t5-blog
% git checkout -b test article3_20090119
% mvn jetty:run

Enjoy, and see you next time !

T5 - Scala : first injection and property access

2009-01-11T10:37:00.013+01:00

The last time, we set-up the Tapestry 5 quickstart application to run with Scala in place of Java. Now, it's time to add our first service and data, to see what are the common idiom we will have to follow to make them work together.

Target scope of this iteration

We want to add only two features:

Two domain objects:

the author for our blog,

a configuration object, which will be a container for blog's parameters (title, author, etc)

a service to access this configuration, injected where needed

After the domain object will be added, I will mmodify the Index page to use them.

User, configuration and service, first attempt

User and configuration objects

So, we want an user with a non-modifiable login, a name/surname, and an email. For now, the configuration will only have the main author (an user), and a title for the blog.
They will go in the same file as they are both related to configuration data:

org.example.blog.data.BlogConfiguration


package org.example.blog.data

class BlogConfiguration(val author : User) {
  var blogTitle = "%s's blog".format(author.login)
}

class User(val login : String) {  
  var commonname = ""
  var surname = ""
  var email = ""
}

And that's it. For the user, commonname, surname, and email are "var", so we will be able to get them with user.email, and set them with user.email = "newValue".
We can note that the type of this properties is inferred by Scala to String. Remember, Scala is statically typed, but that doesn't imply

login (for user) and author (for configuration) are constructor's parameter. As they are tagged "val", they will be read-only, and viewable from other class.

Configuration service

Now, we have to build a service for configuration so that we will be able to inject it where we need it.

Thank's to Tapestry 5 powerful and super-easy IoC feature, it's a matter of adding some lines in our application module:

org.example.blog.services.AppModule


  def buildBlogConfiguration = {
    val author = new User("jondoe")
    author.commonname = "Jon"
    author.surname = "Doe"
    author.email = "jondoe@foo.bar"
    
    new BlogConfiguration(author)
  }

And it's all what we need. Now, let's use this service in our Index page to display some info about the user !

Index modification

Index.scala

The index page modification is really trivial. That's the code for the Scala part:
org.example.blog.pages.Index


class Index {
  
  @Inject @Property
  var conf : BlogConfiguration = _
  
}

We want to access our BlogConfiguration service, so we just declare a variable with the wanted type. The really important thing here is to initialized it with "_"

Without that (for example, if you initialized the var with null), you will get silly error about read-only variable not modifiable.

As we want T5 to inject the real BlogConfiguration service, we annotated the var with @Inject, and as we want to access it from the template and I'm lazy, we also used the @Property annotation, that save us from writing the getter for "conf".

Index.tml

The template part isn't much more thrilling. We want to use the blog title in the page's title, display information about the author, and even update them. That's the full template code:


<html xmlns:t="http://tapestry.apache.org/schema/tapestry_5_0_0.xsd">
  <head>
    <title>Tapestry 5 - Scala blog</title>
  </head>
  <body>
    <h1>${conf.blogTitle}</h1>

    <p>Author info:</p>
    <t:beandisplay t:object="conf.author" />
    <p>Update author info:</p>
    <t:beaneditform t:object="conf.author" />
  </body>
</html>

"${}" is the T5 syntax to say "look into my class, take the blogTitle object in conf object".
"beandisplay" is a component that simply display all the properties of an object, and "beaneditform" is a magic component that fully build a create/update form for the given object.

And now, we test our blog... And that's not at all what we want.

T5 shows us a really insightful error message:

Clearly, Tapestry does not understand that our "conf" object has a "blogTitle" property.

User, configuration and service, second attempt

What happened is that T5 relies on Java Bean conventions to see what properties of an object are available. And Scala does not follow that convention with the auto-generated accessors. As we see in at the begining, Scala use the directly the property name as getter and setter.

So, we have to add traditional JavaBean getter/setter to our User and BlogConfiguration classes, or use the scala.reflect.BeanProperty where possible. This annotation is the Scala equivalent to T5's Property annotation and generate the getter/setter pair for us :

org.example.blog.data.BlogConfiguration


package org.example.blog.data

import scala.reflect.BeanProperty

class BlogConfiguration(val author:User) {

  @BeanProperty
  var blogTitle = "%s's blog".format(author.login)
  
  def getAuthor = author
}


class User(val login : String) {  
  @BeanProperty
  var commonname = ""

  @BeanProperty
  var surname = ""

  @BeanProperty
  var email = ""

  def getLogin = login
}

Sadly, the updated classes look a little more bloated, but now, it works as expected.
If you go to "http://localhost:8080/blog/", you should see :

Of course, if you modify User info and click on "create/update", the user info are really updated in the BlogConfiguration.

And that's over for the time being.

Edit: oups, the code is available here: http://github.com/fanf/scala-t5-blog/tree/article2_20090111

To get the code and run it:


% git clone git://github.com/fanf/scala-t5-blog.git
% cd scala-t5-blog
% git checkout -b test article2_20090111
% mvn jetty:run

And go to http://localhost:8080/blog/

Summary

For now, Tapestry 5 and Scala work together, as soon as you know that "_" is to be used as init placeholder for Injected var, and that T5 use Java Bean convention for getter/setter.

The problem is that we don't really see what Scala brings in place of Java, so why switching ?

We can see it the other way: as everything works at least as well as with Java, I think I will continue this experiment a little bit more : I'm using eclipse with Scala plugin and OK, it's not as good as Java plugin, but it's ok, RunJettyRun has no problem to launch the application, T5 live class reloading works fine, etc.

Moreover, I suspect that as soon as I will come down a little in the application layer, some benefits will emerge - just think to real DAO that take a closure as filter, without having to deal with Java anonymous classes, generic mess, and all that stuff...

Tapestry 5 with Scala - Get the code !

2009-01-07T21:28:00.004+01:00

A Scala / Tapestry 5 blog

In the next days/weeks, I will try to see a little more precisely how Tapestry 5 and Scala get together. I chose to start with a little blog application (how imaginative I am ;)

If your are interested to see how it works, I've set-up a github repository to keep a trace of the evolution.

So, the repository is here: http://github.com/fanf/scala-t5-blog/

Step one : an hello world application

The first step is to have the equivalent of the Tapestry 5 quickstart application, but with a Scala back end. That suppose:

to change Java class to scala one;

to add the correct dependencies and plugins (I used the scala-maven-plugin) for Maven, so that it will be able to compile Scala files.

I also renamed the standard directory structure for source classes from src/main/java to src/main/scala.

And that's it !

Test it yourself

So, if you want to see and test a Tapestry "hello world" application with Scala in place of Java, simply:

install Git if you don't have it already

get the source with the command:

% git clone git://github.com/fanf/scala-t5-blog.git

Go to the scala-t5-blog directory, and switch to the tag for the "hello world" application with the command:
```
% git checkout -b test helloworld-scala-t5 
```

You're done ! You can compile and run it with the standard "mvn jetty:run" command, or make a war to use it with your prefered web application with "mvn package"

That's it for this first step, next I will try to make a more beautiful, perhaps configurable skin for the blog.

Enjoy !

Tapestry 5 with Scala

2009-01-04T20:56:00.007+01:00

I just tested to use Scala for the code used in components for Tapestry 5. For now, all seems to work great !

I just created a default project with the quick-start archetype, changed Index.java and AppModule.java to Index.scala and AppModule.scala respectively, added some render-phase handler in Index, add a filter in AppModule, and all worked fine...

Expect one crucial thing: T5 requires that properties annotated @Persist are not initialized with a default value.

This is due to the fact that T5 components / pages are pooled, and so are instantiated prior to their used, and after use are cleaned and send back to the pool.
The problem is the clean stage: T5 as to know what is a "clean" value for the one managed by the framework - @Persist-ed one the first. That's hard to know for statefull object... as for example a collection of phone numbers, or some credential: T5 can not know effectively if a statefull object state changed, so it can only let it as it is, or nullify it. Nullify it expose you to NPE (because as a developer, you thought the initialization was done on class instantiation), and you don't want to see this kind of information to be badly cleaned and so, maybe leaked elsewhere, when the class in pool is used again.

OK, so it's a good thing that T5 does not let you fire on your foot, and throws an exception if you try to set a default value to such a managed property.
Except... that Scala requires that variable or values have a default value. So for now, I can't use persisted field for components, what is quite a limit :/

I'm going to continue the experiment, to if Scala and Tapestry 5 can be used together, or if I will have to use Scala only for deeper layers of my application (and well, perhaps at last, I will have to try Groovy for the upper layer...)

UPDATE: there seems to be some problem with the IOC, so that will be hard...
Symptoms are that the field is read-only, I will have to look more carefully at the difference between Scala var and Java properties...

EDIT: Thanks a lot too James Iry who pointed to me that the variable initialization should be done with "_" : that's the solution. So just use "Persist var name:String = _", and it works.

ProjectEuler#84 : monopoly game in Scala

2009-01-03T16:40:00.006+01:00

In the last weeks, I slowed down my completion rate of Project Euler's problems a lot. But yesterday, looking for something to do for the last days of Christmas's holidays, I found the #84 problem which seemed quite fun: the goal is to find what are the 3 most visited squares in the game if we played with 4 sided dices in place of the common 6 sided ones.

It's interesting, because it's a probabilistic problem, and I'm lame in proba. So, as the problem does not require too much precision (at contrary to problem #213...), I could solve it in a monte-carlo way. This is the kind of proba solving method that suits me the best, because no proba are used...

As always, it was really simple to express the solution I imagine in Scala, and that's the result.

Be careful ! If you play at Project Euler, the following contains a solution that you may prefer to find by yourself !



/*
 * This is the companion object of our Monopoly class, it's the
 * place where we put all the common and side stuff, 
 * the board definition and our Random number generator
 * definition, for example. 
 */
object Monopoly {
  /*
   * The monopoly board 
   * (yes, we could have just use the square numbers,
   * but I found that clearer at the begining, and the overhead is
   * really small)
   */
  val board = Array(
    "GO"  , "A1", "CC1", "A2" , "T1", "R1", "B1" , "CH1", "B2", "B3", 
    "JAIL", "C1", "U1" , "C2" , "C3", "R2", "D1" , "CC2", "D2", "D3",
    "FP"  , "E1", "CH2", "E2" , "E3", "R3", "F1" , "F2" , "U2", "F3",
    "G2J" , "G1", "G2" , "CC3", "G3", "R4", "CH3", "H1" , "T2", "H2"   
  )

  /*
   * Match a case name to it's number
   */
  val reverseBoard = {
    var m = Map[String,Int]()
    for(i <- 0 until board.size) m = m.+((board(i) , i))
    m
  }

  abstract class Random {
    def next : Int
  }

  /*
   * A simple homothetie from int's range to a new one range,
   * used to transform Random to dice roll
   */
  def randomInRange(start:Int,end:Int, random: Random) : Int = {
    //that was funny to set up, there was some intersting
    //overflow and int division to take care of ;)
    val i = start +
      ((random.next.toFloat - Int.MinValue) * (end+1 - start) / 
         (Int.MaxValue.toFloat - Int.MinValue) ).toInt 
    if(i > end) end else if(i  }

  /*
   * Utility methods that sends three square back 
   */
  def goBack3(square:String) : String = {
    val i =  reverseBoard(square)
    if(i>2)board(i-3) else board(board.size+i-4)
  }

  /*
   * Utility method that given a square, 
   * return the next Railway Company square
   */
  def gotoNextR(square:String) : String = {
    val i =  reverseBoard(square)
    if(i>5 && i <= 15) "R2"
    else if(i>15 && i <= 25) "R3"
    else if(i>25 && i <= 35) "R4"
    else "R1"
  }

  /*
   * Utility method that given a square, 
   * return the next Utility company square
   */
  def gotoNextU(square:String) : String = {
    val i =  reverseBoard(square)
    if(i > 12 && i <= 28) "U2"
    else "U1"
  }
  
  /*
   * Represent a stack of cards, used for Communty cards and
   * Chance. 
   * We cycle throught an array to convey the idea that cards
   * are put back on the stack after use. 
   * 
   * Each "card" is a function that is awaiting for the real
   * square name to return the resulting square move. Most of
   * the card does nothing for us, so the function is identity
   * (return the square itself)
   */
  class CardStack(random: Random, private val size:Int) {
    protected val cards = new Array[String=>String](size)
    for(i <- 0 until size) cards(i) =  (square:String) => square
    private var index = 0
    private def rand = random

    def next(square:String) : String = {
      index = (index+1)%size
      cards(index)(square)
    }
  }

  /*
   * The class that represents the chance card heap.
   * Fairly random card distribution, 
   * see http://xkcd.com/221/ for more details
   */
  class CH(random: Random) extends CardStack(random,16) {
    cards(1) = gotoNextR _
    cards(2) = goBack3 _
    cards(4) = _ => "GO"
    cards(5) = _ => "R1"
    cards(7) = _ => "C1"
    cards(9) = _ => "H2"
    cards(10) = gotoNextR _
    cards(12) = _ => "JAIL"
    cards(14) = gotoNextU _
    cards(15) = _ => "E3"
  }

  /*
   * The class that represent the community chest card heap. 
   * Fairly random card distribution, 
   * see http://xkcd.com/221/ for more details (again)
   */
  class CC(random: Random) extends CardStack(random,16) {
    cards(4)  = _ => "GO"
    cards(10) = _ => "JAIL"
  }

  /*
   * A class that represents a pair of dices 
   * with a given number of faces
   * 
   * The only intersting thing to do with
   * is of course to roll them 
   * (with cards, dices and money involved, I can't 
   * understand where The Monopoly failed to be attractive).
   */
  class Dices(faces:Int,random: Random) {
    def roll = (
      randomInRange(1,faces,random),
      randomInRange(1,faces,random)
    )
  }
}  
  
/*
 * That's the actuall Monopoly representation. 
 * In our simplification of the Game, a
 * Monopoly has a pair of dices, a Community Chest
 * and a Chance heap of cards, a log of the number
 * of consecutive doubles, and a marker for the 
 * current position of the player (notice that as
 * there is only one player, the game should be
 * even less attractive than the real Mo,opoly...)
 * 
 * Nonetheless, we want to play to our game, so
 * we have a "turn" method that roll the dices and
 * move the player thanks to a "next square" method
 * processor. 
 * 
 * And that's all, our monopoly really looks like 
 * the real !
 */  
class Monopoly(faces:Int,random: Monopoly.Random) {
  import Monopoly.{CC,CH,Dices}
  import Monopoly.{board=>B,reverseBoard=>RB}
  
  val dices = new Dices(faces,random)
  val cc = new CC(random)
  val ch = new CH(random)
  var doubles = 0
  var currentPosition = 0

  private def next(square:String) : String = {
    val s = square match {
      case "CC1" => cc.next(square)
      case "CC2" => cc.next(square)
      case "CC3" => cc.next(square)
      case "CH1" => ch.next(square)
      case "CH2" => ch.next(square)
      case "CH3" => ch.next(square)
      case "G2J" => "JAIL"
      case  _    => square
    }

    if(s == square) s
    else next(s)
  }
    
  /*
   * A turn starts at one square and end on another,
   * perhaps passing on several other squares
   */
  def turn() : String = {
    val d = dices.roll
    
    var newSquare = next(
      B((currentPosition+d._1+d._2)%B.size ))
    
    //3 consecutive double send to Jail
    if(d._1 == d._2) {
      doubles = doubles+1
      if (doubles >= 3) {
        doubles = 0
        newSquare = "JAIL"
      }
    } else doubles = 0
    
    currentPosition = RB(newSquare)      
    newSquare
  }
}
  
/*
 * Now that we can have a Monopoly, 
 * we game play a party ! 
 * In Scala, party are called "application", 
 * but it's because software developper are
 * known to be dull people. 
 */  
object Problem85 extends Application {
  import Monopoly.{reverseBoard=>RB}

  /*
   * We want to observe the evolution of
   * the game, so we define a Logger
   * (I'm sooooo unsurprising)
   */
  abstract class Logger {
    def register(square:String)
  }

  /*
   * A looger that just output to console,
   * used at the begining, to see the player
   * evolves...
   */
  trait ConsoleLogger extends Logger {
    override def register(s:String) = println(s)
  }

  /*
   * ... and was quickly replaced by a logger that
   * just keep everything in a map, not that
   * it was boring... Well, actually, it was.
   */
  trait MapLogger extends Logger {
    var map = new HashMap[String,Int]()
    override def register(s:String) { 
      /*
       * ** Note to Java developpers **
       * look how it's easy to say 
       * "I want to retrieve a key value
       * from my map, but if the key does 
       * not exists, defined it with the 
       * given default value" in Scala. 
       * Just think to the number of if, and
       * brackets and the like in Java...
       */
      map(s) = map.getOrElse(s,0) + 1
    }
  }

  /*
   * Aaaaaahhhhhhh ! At last, there is our Game !
   * It's defined with a random generator, the number
   * of face we want our dices to have (remember, 
   * that's actually the point of the problem...), and
   * a limit number.
   * 
   * The limit number is the number of turn that our 
   * game will play before stoping (and we, look to
   * the results). As we are in a Monte Carlo similution,
   * this number will have to be HUGE. Say ONE MILLION !
   * Ok, that's ridiculously small, but thanks to the
   * kindness of project Euler team, the number converge 
   * quickly, and my PC is not as fast as clusters used
   * for real Monte Carlo simulation, 
   * so it will have to do ;)
   */
  abstract class Game(
    faces:Int, 
    random: Monopoly.Random, 
    limit:Int) extends Logger {
    
    val monopoly = new Monopoly(faces,random)
    var square = ""
    var turn = 0
    
    def start = {
      while(turn < limit) {
        this.register(monopoly.turn())
        turn = turn + 1
      }
    }
  }

  /*
   * Oups, don't forget to actually get a random
   * generator. As explained for the Game, we don't
   * need something too sophisticated for this
   * simple example. We may have taken 
   * http://www.honeylocust.com/RngPack/ for a
   * better pseudo-random generator (for example).
   */
  class JavaSimpleRandom extends Monopoly.Random {
    val r = new scala.util.Random()
    override def next = r.nextInt
  }
  
  /* ============================= */
  /*        Actual test            */
  /* ============================= */
  
  val r = new JavaSimpleRandom()
  val rounds = 1000000
  val test = new Game(4,r,rounds) with MapLogger

  print("begins... ")
  test.start
  println("results:")
  val a = test.map.toList.sort( 
    ( x:(String,Int), y:(String,Int) ) => x._2 > y._2)
  for(i <- 0 until 5) {
    println("%5s (%02d): %s".
      format(
        a(i)._1,
        RB(a(i)._1), 
        a(i)._2.toFloat/rounds)
    )
  }
}

Voilà !

Happy new year 2009

2008-12-31T17:30:00.002+01:00

So, we are in 2009. As always, it's a good time to sum up the past year, and plan for the future. Of course, it's not the only moment for that, it's just that it seems to be in the ambient mood ;)

So, what next ? A little report about top things on 2008, and some previsions ? General topics or more personal ones ? Tech or not ?

Well, at least I will list some topic that were important to me, and we will see if a emerging design emerges ;)

- I met really interesting people in 2008, and I would like to especially thank you Bruno for the time spent with us, I hope to work again with you. I would also thanks my team for the good time spent on developing software this year. Other cool people are lurking on #tapestry there were really surrealist and funny moments. And there is all the others I'm forgetting, but thanks for all the good time.

- I miss perhaps one of the best opportunities that I will ever have in 2008. I will have to be less timorous this year, more self confident.

- Java-the-language died in 2008, and perhaps it's a cool new. I only hope that it won't stop the JVM evolution. Moreover, Sun is not in its best wealth to say the least... I can't imagine my future on a MS platform, that's clear (even if F# and C# 4.0 are becoming thrilling). So, perhaps it's time to look more carefully at Android...

- A little think for my Grand-mother who died a 3 weeks ago...

- That's 4 years that I'm Paris, and almost as long that I work on Linagora. That's a long, long time. I will have to do real software developpement in 2009, that's for sure.

- I'm playing with Scala for almost 18 months now, but only for kid work. Perhaps it is time to start real projects with it now...

- I'm developing with Tapestry 5 for almost 2 years now, it's really a wonderful framework. Thank you Howard for that piece of architecture, it's a great work !

Oh, wait, perhaps there's an emerging design here ;)

So, what next for 2009 ? That will have to be a year of major evolution, both on a personal and a professional point of vue. Perhaps it's time to go outside of France, perhaps it's time to come back on the south. Let's see how it can be done.

So, let's go for 2009, let's take the opportunies this year !

Tapestry 5 Final is out !

2008-12-12T09:30:00.003+01:00

At least !

After almost two years of public alpha/beta releases, Tapestry 5 final is out !

The vote for the 5.0.18 release succeeded this night, so perhaps not all the resources are already up to date, but it should be updated soon.

So now, spread the words !

The next BIG task for the community is to write a great and powerful third par component library, something like GWT-EXT. Chenillekit seems to be the best candidate today, even if it's in no way as polish and broad as gwt-ext.

So, Tapestry 5 community, join our force to make T5 really attractive !

Tapestry final coming soon !

2008-11-24T10:21:00.003+01:00

On the tech side, it's a good time for me !

Soon after the release of Scala 2.7.2, it's Tapestry 5 time to reach an RC status (OK, I didn't blog about the RC1, some personal stuff were more important at this time).

Moreover, Tapestry 5 is gaining a kind of hype in Europe, or at least in France : the new official French weather site is coded with T5, and it's a big one (about 800,000 visitors in a day), and I just learn that Unedic[1], the French civil service for the unemployed, which a BIG civil service (as most of them in France ;), chose Tapestry 5 as there new default "ligth" web framework.

I'm quite happy of my choice for T5, almost 2 years ago :)

[1] sorry for the English readers, I didn't find an English description about Unedic :/

Windows refound if when you buy a computer

2008-11-22T17:30:00.002+01:00

It's the first time I ever see that in the description of a new computer. It's saying : "ask a vendor if you don't want Windows Vista with your new computer, the refound is 50€". The computer was an Acer of about 500€, it was in a big electronic french brand, and that's reaaly cool.

Minds are evolving...

Scala 2.7.2 is out

2008-11-10T09:19:00.004+01:00

Here we are, Scala 2.7.2 was released on november, the 10.
And it's a great news !

You may wonder why a minor release seems to be so important ?

C'm'on, it's a palindromic release number, it's so fantastic !

Well, more seriously, it's because this released is the one that will be cover by the coming book "Programming in Scala", and so, this release mark a kind of shift in the Scala language development : Until now, the language was evolving quite quickly, what was great in term of enhancement, but bring some recurring problems, and seems to frighten a lot "the enterprise developers" (or at least there bosses).

With this release, seconded by a great book, the Scala language reach a new level of maturity, and perhaps will gain more visibility outside the rather small (but growing !) circle of first time enthusiastic who use it today.

So, it's a great news for Scala users, and a great time to go and discover Scala !

ProjectEuler#42, aka Scala shines as a scripting language

2008-11-04T10:21:00.013+01:00

I'm still playing with project Euler, and I'm going to love Scala more and more.
Yesterday, I solved the #42 problem, on which we need to parse a text file, and make some simple transformations and filtering on the results (it's why I choose this title, because it's generally the kind of things you expect to do in a scripting language, and well, I'm really
impressive, and I read this morning the post "Scala as a scripting language?", and I say "ho, it's exactly what I felt when I did pb#42 yesterday, let's blog on it, it's fashion :)

So, this problem is a simple Project Euler one (at least, there is no math on it), but just stop and think to what may look the Java's solution. Yes, you will have to deal with Files, input stream, and the like, filtering data, sorting things, and even if it's quite simple, it's always a little too heavy compared to what it may be.

So, there is the full solution in Scala, in a mixed imperative and functional style, as produced in the first sketch version (OK, I'm lying, in the first sketch, I didn't include comments and variables names looked more to 'lsv' and the like, these transformations are blog add-ons).

I'm sure there is a lot of optimizations available, but the important think is that Scala let you program as you think, whitout to much noise and boilerplate...

So let's go for the code:


package ex26_50
import scala.io.Source 
/*
Problem#42
The nth term of the sequence of triangle numbers 
is given by, tn = n(n+1);
so the first ten triangle numbers are: 
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

By converting each letter in a word to a number corresponding to its
alphabetical position and adding these values we form a word value.
For example, the word value for SKY is 19 + 11 + 25 = 55 = t10.

If the word value is a triangle number then we shall 
call the word a triangle word.

Using words.txt (right click and 'Save Link/Target As...'), 
a 16K text file containing nearly two-thousand common English 
words, how many are triangle words? 

*/

object Problem42 extends Application {

/*
 * iterate over all the lines of a file and
 * split each one on ',', remove surronding ",
 * and put the result in a list
 */
def parseWords(file:String): List[String] = {
   for {
     line <- Source.fromFile(file).getLines.toList
     s <- line.split(",")
     if(!s.isEmpty)
   } yield s.replaceAll("\"","") 
}  

/*
 * Simple mapping function that associate
 * each char to it's value (position in the alphabet, begin to 1)
 * and a word to the sum of its char value
 */
  def wordValue(s:String) : Int = { 
    var sum = 0 
    for(c <- s) {
      // iterate over the chars of the string
      val cval = c.toInt
      if(cval >= 64 && cval <= 90) {  
        // 64 = ascii val for 'A', 90 = ascii val for 'Z'
        sum = sum + cval - 64 
      } else {
        error("Unauthorized char: " + c.toString) 
      } 
    }
    sum
  }

/*
 * That's the definition of the list number on witch we will work:
 * - parse the file to a list of word
 * - transform each word to it's word value 
 * - sort the resulting, so that we can know the
 *      upper bound of our triangle value to caluculate            
 */

  val list_wordValues = 
    parseWords("src/words.txt").map(wordValue(_)).sort(_ > _)

//we also see that in Scala, Format syntax is actually usable
  println("Max value in %s words: %s (min: %s)".format(
      list_wordValues.size, 
      list_wordValues.head, 
      list_wordValues.reverse.head))

  /*
   * Given the upper bound,
   * generate the set of triangle number
   */
  val set_triangles = {
    var set = Set[Int]()
    var n = 1
    var i = 1
    while (n < max ) {
      n = (i * (i+1))/2
      i = i + 1
      set = set.+(n)
    }
    set
  }

  /*
   * That's all, we just have to filter the list of words to
   * only keep whose which are in the set of triangles value,
   * and take the size of the resulting list.
   */ 
  val nb = list_wordValues.filter( (i:Int) => 
             set_triangles.contains(i)).size

  println("Found %s triangles words !".format(nb))
}

I love scala :)

PS: It's the full working solution, appart from the leading "_", sorry for the formatting, it seems that blogger is not the most friendly for code formatting. If somebody has some hint on that subject, I will be glad to heard them (ok, perhaps I should have a look on the plugins)

EDIT: I found a way to highlight code thanks to SHJS. Thanks to the author for this plugin that wasn't to hard to make it work with blogger, and which the only Javascript highlighter that supports Scala :)

On static vs. dynamic type systems in programming languages

2008-10-22T08:57:00.011+02:00

I'm a "static typed languages" guy. Whose who know me see what I mean :)

The Rail's boys would say it's because I'm frightened by the field of possibilities, the freedom of dynamic languages [1]. I believe that it's more certainly because I came to software development through OCaml, a really good static typed language, and not like a vast majority of developer through languages from the C family (Java the worst among them [2]), which really missed the point of most of the advantages of static typing (yes, one days I will write about how enlightening was my experience with the Coq Proof assistant, and why things like FPH are beautiful)

So, because I'm dealing with Javascript, Pearl, Ruby and Python fan boys quite often (Lisper and Smaltalker are somewhat rarer ;), I would highlight this really good article about static and dynamic type systems, and the fallacies that most programmers believe about statically typed language : http://www.pphsg.org/cdsmith/types.html.

Synopsis:

Fallacies About Static and Dynamic Types

Many programmers approach the question of whether they prefer static or dynamic types by comparing some languages they know that use both techniques. This is a reasonable approach to most questions of preference. The problem, in this case, is that most programmers have limited experience, and haven't tried a lot of languages. For context, here, six or seven doesn't count as "a lot." On top of that, it requires more than a cursory glance to really see the benefit of these two very different styles of programming. Two interesting consequences of this are:

Many programmers have used very poor statically typed languages.
Many programmers have used dynamically typed languages very poorly.

This section, then, brings up some of the consequences of this limited experience: things many people assume about static or dynamic typing that just ain't so.

And as I clearly fit in the category of "programmers [who] have used dynamically typed languages very poorly", I have to find the same article about fallacies on dynamic type language.
I would really enjoy stuff about run-time optimization, contract on dynamic language, meta-programing [3] and such things.

[1] actually, when I see something like Jquery, I understand that Javascript is somewhat amazing. I will have to look harder on it.
[2] when you reach something like that to get a real static type check for something like an heterogeneous list, then you know that something goes wrong.
[3] it's something that is possible in static typed language,as for example with OCamlP4, but I believe meta-programing in Lisp (for example) is more powerful, and the concept of meta-programing is more spread in dynamic typed language. It may be one of the fallacies ;)

Metting Tapestry father - Howard Lewis Ship in Paris

2008-10-09T09:35:00.011+02:00

Thuesday the 7 october, I met Howard Lewis Ship, the father of Tapestry 5 Java web framework in Paris.
He was here for a 3 weeks trip in Europe, far from its home, Portland, USA.

There were Howard, his wife Suzan, and almost all my developers team, so 5 people from Linagora, all of them T5 addicts.

Evening part I : bar and T5

Imminent release of 5.0 final....

The evening began with a beer (or two...) in a bar near Linagora, and the discussion almost immediately started on Tapestry 5. Howard wanted to know how we came to T5, so I explained that I'm following its development since 5.0.1 and that I didn't chose at all by luck T5. Now, every developer in my team use T5, and quite like it.

We chatted about the iminent release of T5.0 final (YES !), the beauty of the framework thanks to the IoC framework, its scalabity, not only in performance, but in all thinkable meaning of the term : scalabitly in component from technical ones to business ones, scalabilty of the T5 user target from the business oriented people to the the technical nerd, etc.

We also discussed the missing points, around the documentation and some little things (what bring me to a ml post on the subject).

... and Tapestry 5.1 project...

The discussion followed on the 5.1 release, it's short, time-based and not functionnality-based release cycle, every 3 to max 5 month.

I think this is a really good new, because it was one of the most recurrent criticism against Tapestry : its really really long release cycle, along with the compatibility issue between them. Even if Howard came back several times on the last point (it's even explained in the T5 home page, at the bottom), upgrades would be even smoother if there is less time between them. Moreover, from a customer point of view, it's always best to have his product based on a stable release. I mean, a release tagged stable, because T5 is already one of the most stable soft I used, but the "alpha" or "beta" status is something quite frightening for a customer...

Afterwards, Howard gives us the possibility to argue for our "most wanted feature".
This is our wish-list, along with what Howard expects :

Portlets

That would be a great feature, because the component approach to the web really goes together with the portlet world. Howard thinks that it should be rather simple to make T5 portlet aware, because most of the needed abstractions are already here. And it's one of the things that should go in T5.1, so, we may be dreaming to cool webadmin interface with T5 in a portail in a near futur

Webflow

That's another point that came back several time in the mailing list, and that is already in the T5.1 scope. Howard seems to be in discussion with Keith Donald to integrate Spring Web 2 and Tapestry 5 together.
Plus, this is a really good feature to ship, especially directed to the IT managers. It's the kind of tool that make them think they can actually develop using boxes and arrows. I'm not completely sure I want Spring web flow integration into T5, but I definitely want a conversation persistence scope, along with a clean way to manage "wizards". So, if it has to come with Spring Web Flow integration, so be it...

skinning / themes

Howards was quite enthousiastic about the skinning and theming possibilities he envisions for 5.1. It would be a kind of sitemesh, for free, thanks to a T5 component.

OSGi

We chatted a little about OSGi. Several people on the ml already tried to integrate T5 and OSGi together, with more or less success. For now, I'm not quite sure of OSGi, I think it lacks a lot of all the plumbery that T5 so nicely hide to developpers... Perhaps Spring Dynamic Modules is the way to go, but for now, I think its use cases should remain in the proof of concept level.

That was the main points, but we also talked about other framework as Terracotta, and ideas as ""CRUD should be free" (I would just add "as long as it is a side module, and not in the core". That's not really a problem with T5 and it's pluggable architecture, but for example, all the CRUD stuff is of no use in InterLDAP).

...in an evolving Java ecosystem

The last discussions in the bar where less focused on Tapestry, and more on the Java ecosystem. Java 7 came in the discussion, and I was happy to discover that Howard seems to share most of my view on the subject. He agree that the JVM need optimizations (faster, more plugable, more versatile, etc), but that Java the language should not evolve anymore...
We talked about Scala and Groovy, his preference going to the second one (obviously, mine is in the first :), but he really likes the lazy evaluation possibilities that Scala bring.

Here, there is something that I don't understand... For a functional developer, all Tapestry architecture is built around functional concept, I see map/fold and pattern matching every where in Tapestry :)

Jean-Louis, one of my co-worker, talked about his "easy ant" project - take the best of Ant and Maven dependency management thanks to Ivy. A to-be-followed project.

Evening part II : "La Casita" restaurant

For the end of the evening, we moved to "La Casita", a french restaurant near Les Champs Elysées. It's a typical France South-West cooking restaurant, with Champagne, Foie Gras, snails, duck, wine, cheese... And to my great pleasure, Suzan and Howard seemed to enjoy it !
So much for our French a priori and cliché about American taste :)

There, we talked less about Tapestry, and more on general subjects. We chatted about the difference on open source in USA (more pragmatic, due to cost efficiency) and in France (more philosophical and political).
We also had an input around the use of IRC, and the complementarity this communication channel can have with the traditionnal mailing list (folks, come in the Tapestry irc chan : #tapestry on freenode).

See you next time !

Along the night, I tested the Ballmer Peak applied to English spoken skills, and went at least as far in the curve as Millenium developpers...

For me, it was a really really great evening, Howard and Suzan are really nice people.
Moreover, Howard is one of the best architect I know in the Java world, it was a great pleasure to meet him. Suzy is realy nice, the next time I will have to invite my girlfriend too :)

So, thank you Howard and Suzy for this meeting, and see next time (in Portland ?)

Java Bar Camp Mardi 30 septembre

2008-09-30T23:15:00.006+02:00

J'ai participé hiers soir à mon premier "Java Bar Camp" à Paris, dans les locaux de Octo Technologie.

Avant d'aller plus loin, je tiens à remercier les organisateurs, mis à part le retard sur l'arrivée des participants, tout le reste a été très bien géré, bravo !

Premières impressions : ce n'est pas du tout ce à quoi je m'attendais. Je m'attendais à un rassemblement de geek & développeurs barbus, alors que l'assemblée était beaucoup plus hétéroclite, avec une forte coloration consultant/chef de projet.
Les thèmes s'en sont fortement ressenti : méthodes de développement, build et tests étaient à l'honneur.

Mais revenons sur le déroulement de la soirée :
- 18h30 / 19h30 arrivée des participants (un peu de retard, Julien Dubois (M. Spring en France) absent (il est papa :), toutes mes félicitations )
- 19h30 :
* tour de salle : chacun décline nom/prénom, et 3 tags, des sujets qu'il souhaite évoquer - dans un bar camp, tout le monde est acteur ;
* après le tour de salle, chacun est libre d'aller inscrire sur un post-it le sujet dont il souhaite parler parmi les tags;
* 8 sujets sont choisis parmi les post-it, organisés en 2 sessions (donc réparti dans 4 salles)
- 19h45/20h35 : première session : TDD/Test ; Licenses OSS ; Spring vs JEE ; ? ;
- 20h40/21h30 : seconde session : usine logicielle (build, maven...) ; scrum en vrai ; ? ; ?
- ensuite, buffet et discussion libres.

J'ai choisi en première session JEE5 vs Spring (à regret), et en seconde session "Scrum en vrai".

Je ne vais pas m'éterniser sur la première session, orienté "débat", et il fut relativement stérile et consensuel. Rien n'émerge clairement, sauf que "certain client ne veulent que des normes, et JEE s'impose", "Sans Spring, Java en entreprise serait sûrement mort, bouffi par sa complexité". Bref, rien de nouveau. Le point de vu de Julien aurait sûrement mis un peu de couleurs.

La seconde session m'a beaucoup plus plû. J'y ai rencontré Eric Mignot de Pyxis, un "évangéliste Scrum", intégriste (dans le bon sens ), qui m'a permis de voir le chemin qu'il reste à parcourir dans sa mise en place dans les projets auxquels je participe, mais aussi de prendre consience du chemin déjà parcouru.

Après avoir revu les bases de scrum (organisation, objets), nous avons abordé les problèmes contractuel, la gestion de l'architecture, la gestion humaine des équipe.

Le mot qui revient le plus souvent est "engagement" : un projet Scrum ne peut pas fonctionner si toutes les personnes y prennant part son convaincu par la méthode, en particulier si le scrum master n'a pas un soutient indéfible de sa direction, et si le product owner n'a pas le pouvoir décisionnaire sur les paiement/le budjet et sur le périmètre fonctionnel.

La fin de la soirée étaient agréable, les groupes se formant et se séparant au gré des discussions, souvent pationnée.

En résumé : une expérience intéressante, un fin de soirée nettement plus intéressante que le début, et je reste sur ma fin en terme de développement pur - ce n'est pas dans ce genre de soirée que je parlerais de Scala ou de language fonctionnels :)

Project Euler - Scala

2008-09-30T10:34:00.003+02:00

I discovered Project Euler, a website that purpose a lots of Mathematical problems that can be solved with programming. The website provides a check of you solution, and a forum to discuss it but only after you give the rigth answer.

Scala really shine in this kind of game. Well, I think that any functionnal language, and perhaps Ocaml even better that other (thanks to it's amazing vm), are really well fitted for this kind of small, algoritm instensive tasks.

The first problems are really simple, and brute force works well, but quickly it is not enonght, and the game become really interesting : it force myself to remind old memories of school, and I'm afraid at the size of the hole in them - I mean, I should have followed some advandced Maths courses in classe préparatoires, and it's almost if I have to discover again all the concept and properties and theorems... A good reason to do all the Project Euler problem till the last one !

Amazing Mythical Man Month

2008-09-30T09:48:00.005+02:00

Fred Brooks was rigtht. Well, I know I will not have a Nobel for this fantastic discovery, but each time I refer to the TMMM, I'm really impressed by the insight of the man.

Ok, so, to be more specific : TMMM has 33 years. He is older than me. And Fred Brooks already depected most of the Agile programming method (history is constantly repeating itself).

But perhaps what impresse me the most is that he forecasted 33 years ago what is happening with Open Source software and the JVM ecosystem today : we will build better and cheaper programms only if common, higth-quality tools and library are broadly available.

It's (almost, but if we look from a hight level, it's not too bad) what is happeing in the JVM (do not read Java) world, and tools like IVY and Maven, Superpackages (ah, not yet) only make it happens quicker.

The future will be intersting, if Sun does not break everything (I hope it's too late for that now).

About me

2008-09-29T09:22:00.000+02:00

OK, since I broke the rule I decreed in the first post, at least I should let some information about me.

I'm François Armand, I'm French (Paris) and work in software development for an open-source company, Linagora. My daily work is mostly with Java, with all the drowback it brings - and some quite good surprises from time to time, especially about the wealth and diversity of its ecosystem (but this point is more about the JVM's ecosystem than Java-the-language).

I'm rather new in computer related stuff, since my first programms where done when I reach the master cycle (don't now exactly how French's 'Grandes Écoles" translate in other cultures - for whom who migth be curious, I'm from "ENSIIE"). It was in september 2001.

I keep from that period a deep interest for functionnal programming, and especially a real good memory in my 2004 research project (the one for the end of school's master cycle), when I was allowed to take part of the INRIA's CompCert (Certified Compiler) project and had a deeper look into Ocaml and COQ (a great program prover - well, not exactly, see by youserlves). I will thanks for that Sandrine Blazy and all the people I met in this time (Xavier Leroy, Yves Bertot and others).

The following is more boring. I met the "real world, with real programs and stuff that matter", say Java and Web development. Hum. Well, all is not dark in this side of the world, because I work in company deeply involved with open source software, and I take part of some really good projects, as for example the FederId project, in which I was the developer of InterLDAP-WUI.

All in all, I'm not a real common Java developer, and it's perhaps why I'm looking toward Scala, or Tapestry 5.

OK, that all for now, just a last sentence to link my linkedin profil (I'm also on viadeo, and I believe that the two are rather out of date).

Tapestry 5, Scala

2008-09-29T09:13:00.000+02:00

Since the first time I played with Tapestry 5 about 18 months ago, I know it would be great, and the more I use it, the more I see how well thought it is. But again, the more I see the limitation of Java-the-language.

I really need to test again Tapestry 5 with Scala as a back-end - Yeah, Scala is the other hot-thing I follow since about the same time, and at that moment Scala/T5 was working fine. But hence Scala evolved a lot, and T5 relies deeply on Javassist and byte code manipulation, I fear that I may encounter some bad surprises, especially in real-life application.

One more item in my to-do list :)

Java 7, aka the Rubicon

2008-09-23T13:39:00.000+02:00

I'm looking forward to write something about Java 7, and why it makes me feeling more and more uneasy. To summarize my thinking, I believe that Java, the language, can not continue to evolve without a clean deletion of old, not alway smart or still relevant design choice of java 1 to 5, but that the JVM have a great deal to play as the new open runtime environment.

Hope I will find some time to develop it a little, at least it's writing somewhere.

Hard to get OpenId

2008-09-16T09:51:00.000+02:00

The so called standard authentication standard, with all its hole and drawbacks, is becoming a required tools... So, I have to open a blog to get an OpenID (google already has so many infos about me... Of course I trusted them, they are so nice...).

Don't expect real post here :)