Julien Viet's blog

CRaSH 1.3 beta3

2013-09-02T00:00:00-07:00

The development of CRaSH 1.3 has been started a few months ago. The website now provides a 1.3 section for people that want to play with the 1.3 betas.

I haven't talked much about it so far but I think it's time to unveil what will be in this new version.

Polyglot

It makes a lot of sense to widen the scope of CRaSH and provide support for more JVM languages. Integrating a dynamic language is not hard, however creating an API for the interactions between the target language and the CRaSH runtime requires more work.

Surprisingly the first supported languages in this new beta is ... Java! With our experience we have now the possiblity to easily dynamically compile Java at runtime (using the Tool API). You can see that as a proof of concept of decoupling CRaSH from Groovy (it was actually less coupled than I originally thought). Simply put now you can have .java commands and they will just be compiled fine by CRaSH (jmx command written in Java).

In the next iteration (beta4) we will focus with the integration of the Ruby language. I have been learning Ruby for the past few weeks and the language does not seem hard to learn, however I am lacking of experience for defining a decent Ruby API. So we are looking for someone with Ruby experience that could help us to define such API:

Creating a command in Ruby
Invoking a command from Ruby
etc...

For Groovy I have the chance to know pretty well Guillaume Laforge and he often provided a lot of guidance for providing a great Groovy API. We are looking for anyone that could help us doing the same for Ruby. If you know such great guy, ask him to poke us on the crash-users list.

Improved Groovy support

Until CRaSH 1.2 we focused on the Groovy language because it is the best dynamic language for Java developers on the JVM. It took several iterations to provide the best Groovy support and this version covers the part for invoking commands from Groovy and how to assemble them in a command pipe line, here is an overview of the API:

Evaluating a command

A command name evalutes to a Groovy closure, allowing to call the command just like a function:

help()

Evaluating a compound command

Sub commands can be invoked by resolving a new closure from the initial command:

thread.ls()

Passing options and arguments

Command options and command arguments are passed as invocation parameters, options are used as a map or named parameters and arguments are the other invocation parameters:

thread.ls(h:true)
system.propget("file.encoding")
log.send(m:"hello", "the.category")

Command pipeline

Pipelines can be assembled with the | (pipe) operator. When a command closure is combined with a pipe, it returns a new closure that will invoke the pipeline:

(system.propls | egrep { "java.*" })()

A pipeline can also contain Groovy closures in addition of the existing commands:

(thread.ls | { Thread thread -> [id:thread.id, name:thread.name] })()

Extended REPL

REPL stands for Read–eval–print loop, which is what you have when you have an interactive session with CRaSH. Until version 1.2, the only REPL is a language close to bash shell for invoking commands or creating command pipelines.

Since CRaSH 1.3 will be polyglot, this new version provides polyglot support for the REPL. The new repl directive allow you to switch to other REPL implementation and we provide in this beta a Groovy REPL:

% repl groovy
Using repl groovy

In this mode you can type plain Groovy (it is similar to Groovy Shell) and most importantly you can use the improved Groovy support seen above, for instance:

% (thread.ls | { Thread thread -> [id:thread.id, name:thread.name] })()
id name
------------------------------------
2  Reference Handler
3  Finalizer
...
% cmd = thread.ls | { Thread thread -> [id:thread.id, name:thread.name] }
thread.ls | Script14$_run_closure1@47da4d19
% cmd()
...

Asciidoc documentation

The documentation is now written in Asciidoc, it is in many ways similar to the previous documentation. Asciidoc has gained a lot of traction in the past months thanks to the great job of Dan Allen on Asciidoctor and GitHub provides a native support for Asciidoc providing a decent doc preview. The 1.3 doc is also deployed live on the site as a preview.

Wrap up

CRaSH 1.3 will provide polyglot support with additional languages such as Ruby as main theme. The Groovy language support has been strenghtened providing the best Groovy support so far. You can download the 1.3 beta or read the documentation from the website.

Devoxx University

2012-11-14T00:00:00-08:00

CRaSH session

Alain Defrance and myself arrived in Anterwerpen Sunday evening with a train from Paris with the main goal of finishing the preps for the CRaSH Tools In Action. We've have been working on CRaSH to finish the features for the demo we wanted to show but we did not have time to reharse together since I was in vacation for a week until this day. However we did prepare it carefully for a long time by creating a precise storyboard of the presentation and focusing on the structure, the flow and the interactions between us. Until the last hour we worked on improving those stories and fine tuning them until it became obvious for us and for the audience. I was a bit scared as we did not reharse them before, but it turns out that the impact on the presentation was almost none and everything went fine.

We had 4 demos packed in half and hour, each demo showing a couple of aspects of CRaSH. This choice was good because it gives a natural structure to the talk, minimizes the demo failure risks. One key point is to have a good flow between the demos, so the transitions are easy for the audience.

Out Of The Box

We show how to download and install CRaSH, the directory layout and the base configuration., After that we run the standalone mode and show basic commands that are immediatly available. At the end of the demo, we show the new crashub.org site and the web demo, allowing the audience could use CRaSH from their laptop during the talk!!!

The Swiss Knife

We explain the concept of attaching CRaSH to a running JVM and in this part we connect to JBoss AS. Thanks to the log command we print a message on AS7 console to show that the JVM running CRaSH in JBoss AS. Then we showed what CRaSH brings to the EE developer with commands:

JNDI : a jndi viewer, for instance jndi find list the content of the naming tree.
JDBC : open an existing an JDBC connection from a JNDI datasource and use it out of the box
JPA : the new companion of the JDBC command that provides access to your entity beans, allowing to perform live JPA QL queries

Extend your runtime

This time the goal is to show we can embed CRaSH in a runtime and create commands interactively. CRaSH is started and configured by a context, in this case CRaSH is started as a Spring bean. Then we code a live command: the Twitter commands which retrieves twits from a Twitter service Spring bean. The command is accessed via an SSH connection.

Monitoring

The last part attaches CRaSH to a Tomcat server. The new jmx commands allows to retrive statistics from the Tomcat MBeans, we combine this command with the sort command and make a command pipe to process an object stream that gets data from the Tomcat MBeans, sort them and display tabular data. We conclude the demo by showing the new CRaSH dashboard feature and put the JMX pipe we previously code in the dashboard.

Although most of the talk is about demoing CRaSH, we had a few slides we used to drive the presentation. We had a very good attendance, considering the time the talk was given and the hard competition against other slots, we had a great feedback on Twitter about the demo that people loved.

Finally, it was a long time since I wasn't on stage, I was a bit anxious until the last minute given how large the stage is and how small we are (you can look here). But once it started I felt very comfortable and was very proud to show our stuff.

Hackergarten

On day 2 we participated in the Hackergarten the whole day. Many open source developers showed up and the competition was hard to get people involved. It looks like at the end, not many external people contributed to the Hackergarten and the present open source developers end up contributing on their own project. It was a great social experience though I think, as open source guys from different projects could discuss, share ideas and create bridges between projects.

On our side, Stefan stepped up and was interested in creating a synergy between Grails and CRaSH. He spent the whole day to create a Grails plugin that embeds CRaSH in Grails. The code will be contributed to the crashub organization as a new project and that's a great win for CRaSH :-)

Alain Defrance started to reuse most of the Swing VisualVM plugin to create an Intellij plugin. You can expect to see this soon.

On my side, I fixed a couple of bugs in CRaSH and spend lot of time talking with other people. I had an long and fruitfull discussion with Dan Allen about Arquillian, testing and open source. I also had the opportunity to show Juzu, the web framework I've been working on for a year to a few JBoss folks that seemed to like it.

Now we will to enjoy the rest of the conference and spend time in the conference!

CRaSH at Devoxx 2012

2012-11-01T00:00:00-07:00

The main CRaSH team, i.e Alain Defrance and myself will be present at Devoxx 2012 for from Monday to Thursday evening.

On Monday 12th we will present a Tools in Action session. The Tools in Action format is a perfect fit for showing how you can use CRaSH in your daily work. It does not require any particular knowledge except being familliar with Java :-) .

During the session we will show you three use cases that CRaSH can solve:

CRaSH the developer's swiss knife
Create custom dashboards for aggregating statistics and metrics of the JVM
Add a Command Line Interface to your project
How to write a shell command

During the talk you will learn how to use CRaSH, the new features of the upcoming 1.2 release and more, here is a teaser video!

On Tuesday 13th we will be present at the Devoxx Hackergarten. The Hackergarten a great opportunity for being involved in CRaSH development, there are many ways for being a contributor, we have some ideas, but the best is that you come with your own :-)

The other days we will enjoy the conference and have a great time!

CRaSH 1.1 release

2012-08-06T00:00:00-07:00

Released today after a 2 months of work, featuring:

Color and styles

CRaSH now supports shell color and styles for increasing the readability of your commands, for example:

The same command in CRaSH 1.1 with better color and formatting:

Spring support

CRaSH can be embedded and configured as a Spring bean providing automatic access to your Spring beans. Writing CRaSH commands that leverage Spring beans is now trivial, now you can extend your Spring applications with CRaSH!

Standalone mode improvements

The standalone mode has a few improvements:

a conf/crash.properties has been added for configuring the shell
the SSH connector has been added

Download

CRaSH can now be fully downloaded and we also provide smaller archives depending on the bundle you like:

CRaSH All : all the available bundles
CRaSH Standalone : starts a JVM or attach to it a running JVM
CRaSH Web : the classic web application bundle
CRaSH Spring : embedded as a Spring bean in a web application
CRaSH GateIn : extends the web bundle and adds specific GateIn features like Java Content Repository support

Finally

If you want to learn more about those features, they have been explained in this nice screen cast:

CRaSH 1.1-cr1 released

2012-07-10T00:00:00-07:00

We just released 1.1-cr1 with the following noticeable changes:

The most visible feature is the support of text styling with colors and decorations, a few commands already use it such as “thread ls” or the jdbc command, it is also quite easy to use when writing a command.
Spring embedding allows to embed CRaSH in Spring and its plugins as Spring beans. In this mode, CRaSH commands can access the Spring beans registered in the Spring bean factory allowing to extend easily Spring applications.
There is now a crash.properties file in the standalone crash configuration directory providing a default configuration.
The SSH connector is now deployed in standalone mode.
Enhanced documentation for the developer section.

You can get the links as usual from the project page and the release notes from the JIRA.

Juzu 0.5 released!

2012-06-27T00:00:00-07:00

After a few months of hard work, Juzu 0.5 is released with many improvements:

First of all, the documentation has been improved with two new chapters in the tutorial and a new reference guide
The plugin architecture has been improved and provides new plugins
Asset plugin: now you can declare the scripts and stylesheets
Ajax plugin for easing the creation of Ajax requests
LESS plugin to transform .less stylesheet to .css stylesheet at compile phase
Portlet plugin to generate a Portlet class and inject portlet preferences at runtime
Templating Service Provider Interface for supporting additional template engines in Juzu such as the integration of the Mustache template engine

Here are a couple of features we have added to Juzu as screencats:

Juzu LESS plugin

Juzu application with Eclipse and Maven

We are now going to work on the Juzu 0.6 release focusing on:

Standalone mode: take Juzu outside of the portal world and create standalone applications
Bean validation integration

We will provide milestones for those features as 0.5.x releases so you will be able to use them and give us feedback. If you are interested in following the development of Juzu or want to be involved you can join the Juzu Google Group.

You can download Juzu or use it from Maven.

Juzu has Mustache!

2012-06-08T00:00:00-07:00

Juzu 0.5 will be released soon and will provide many new great features. Among them now the Mustache templating engine is supported. Mustache is a logic-less templating engine that is language agnostic:

It was important for me to support a second templating language and Mustache is a great choice because:

it demonstrate that Juzu can use different templating engine
some people wants logic-less languages and try to avoid code in templates
it provides that Juzu core is not coupled to the current templating engine
Mustache.java implementation has a good architecture and is easy to embed / integrate
Mustache is easy to use and understand
Mustache can also be used on the client side and later an application could use the same template both on the server and the client

The integration relies on Mustache.java:

mustaches (that’s the name of a mustache file) are also in the “templates” package and ends with “.mustache”
mustache are used and declared exactly the same way than .gtmpl templates (i.e @Inject Path(“index.mustache”) Template
Mustache can also have type safe parameters using the pragma notion which is an extension of Mustache.java : anywhere in the template
At the moment taglibs are coupled to the native groovy template engine and cannot be used. I don’t know if it’s feasible to be able to integrate a tag lib with a .mustache
5/ Mustache is not embedded in Juzu core and instead is provided as an independent jar : juzu-templating-mustache . The main reason is that Mustache.java relies on the Mustache.java library but also on Google Guava. I want to keep juzu-core the less coupled to third party library.

CRaSH feedback after Devoxx FR 2012

2012-05-18T00:00:00-07:00

My CRaSH quickie had a good attendance at Devoxx and it was great to see many folks interested in the project.

Romain and Fabien blogged about CRaSH and the feedback is good (although short but it was at 15mn quickie after all :-) ). The blog are written in french language though.

The 1.0 release was done also during Devoxx and now the project’s follower on GitHub has increased to more than 60 persons.

Devoxx FR 2012 was a great moment and a fantastic opportunity to evangelize CRaSH. We are now actively working on the forth coming CRaSH 1.1, stay tuned and follow the project!

CRaSH 1.0 released

2012-04-23T00:00:00-07:00

After two years of development, I’m proud to release CRaSH 1.0:

CRaSH started as an experiment during my Christmas vacations late 2009 and evolved to become the extensible shell for the Java Virtual Machine offering many exclusive features like:

SSH and Telnet connectivity
Standalone and attach mode
Extensible with hot reloading commands
Ready to use: JVM management, JDBC access, etc…
Powerful contextual completion
Pluggable authentication
Easy to embed
Java Content Repository plugin for eXo JCR and Jackrabbit servers

I want to thank the people that make this possible since the inception: Arnaud Héritier, Alain Defrance, Guillaume Laforge, Emmanuel Hugonnet, Henri Gomez, folks that helped in some kind at some point and of course my company eXo Platform for letting me spend a significant amount of time at my free will on this great project.

The release was done last Thursday during the Devoxx France conference where I had the opportunity to present CRaSH during 15 too short minutes: thank you Devoxx France for believing in CRaSH and giving me the opportunity to demonstrate the interest of the project. I’m sure that now many people will find an interest in CRaSH because it fill real and growing needs on top the JVM:

Extend any kind project with a professional Command Line Interface
Take control of a JVM in a couple of seconds and make it transparent

Although 1.0 is released the project, I have plenty of crazy ideas for CRaSH’s future although I don’t have a formal roadmap yet (I never have actually…), so expect the project to evolve and provide even greater features.

CRaSH is open source and minded, if you can improve CRaSH with a crazy idea, we are open to your contributed features!

Last but not least, we have setup of group for CRaSH users, our community is growing fast: don’t hesitate to join us!

CRaSH Standalone

2012-04-13T00:00:00-07:00

I’m very glad to announce the availability of standalone version of CRaSH. CRaSH standalone is an alternative way to use CRaSH, designed to be usable out of the box from the command line.

And there is more! A few months ago when I was looking at the jvisualvm source code I found the attach API. The attach API allows to plug an agent in an existing and running JVM (that’s what jvisualvm uses natively) and I thought it would be a great feature for CRaSH. I quickly got a prototype running but it took a while to make it usable out of the box.

The standalone version comes with the 1.0.0-cr2 we just released, for this matter I have recorded a screencast to show how easy and powerful CRaSH standalone can be:

CRaSH 1.0 CR1

2012-04-04T00:00:00-07:00

After a bit more than two years of development CRaSH is about to reach the 1.0 status, the candidate release 1 was just released with a few achievements:

The CRaSH website was launched a few days ago to give a better face to the project
Many improvements were done to finish the work (standalone & attach mode, jackrabbit support, etc…)

Last but not least I will give a quickie at Devoxx France on CRaSH to show what CRaSH is able to do and what it can do for you.

JSON to Java with JDK6

2011-12-26T00:00:00-08:00

There are multiple frameworks for transforming a JSON expression to a Java object tree, but the Java Platform does not come out of the box with some javax.json package (I heard there are plans for that).

Today I will show that you can easily transform a JSON expression to a simple Java object tree (map, arrays, primitive wrappers and string) with Java 6 and no additional framework.

Obviously, it may not be the best way to proceed, specially when it comes to speed, security or java mapping. However this solution is appropriate if those are not a concern and you don’t want to add a dependency to an external library for parsing JSON expressions.

The solution relies on the javax.script package and its Javascript binding. Indeed what’s best than Javascript to parse JavaScript Object Notation ?

The scripting API provides evaluation of any Javascript which is nice, unfortunately native Javascript objects are not usable from Java, but the magic of Javascript will come to the rescue!

Javascript is a dynamic language which allows to modify its meta object protocol (MOP) to add new functions on native Javascript objects, through the concept of prototypes. We can modify each of the base Javascript type’s prototypes to add a toJava function that will return a Java version of the object:

Now you probably get the idea, each toJava function returns the Java counterpart of the Javascript object. Initially I wanted to iterate the object tree, but extending the types thanks to the prototype is a much better solution.

We also need to add the missing Java part that loads this JS and uses it to create our Java objects. This is trivial to do thanks to the scripting API, here is how to load the Javascript and setup the engine:

Now we need to use the engine to convert JSON expressions:

Here there is a little trick: you can remark the usage of AtomicReference and it may look inappropriate since we are not dealing with concurrent programming. The trick is that if we return a String from the engine to Java, the engine will wrap it as a Javascript string and we want to avoid that. The AtomicReference makes the value opaque to Javascript and the Java code will unwrap it.

Those three pieces together makes a lightweight solution to transform JSON expressions to Java objects. There are certainly corner case not handled in this code, but it’s a solid basis to start with, I saved the code in a GitHub gist there.

Juzu 0.4.2

2011-12-12T00:00:00-08:00

We have been working hard to get this release done with a great set of new features!!!

First and foremost, I’m very proud of the level support we have now reached for Eclipse. As you may know, Juzu relies much on Annotation Processing Tools (APT) since the beginning to bring exclusive features. Making Juzu work with Eclipse incremental compiler was very challenging because APT simply works differently. Among those features, the type safe template parameters with Eclipse is showed in this screencast

The dev mode feature has been improved a lot, specially now the error reporting is more accurate and sexy, this screencast will teach you everything about switching an application to dev mode in Liferay

Juzu comes as a package to download on this page. Alternatively you can also use the maven archetype to bootstrap an application

Finally, the Dependency Injection has been improved in order to allow the injection of external providers, in particular this is useful if you are using Juzu in the GateIn server and you want to inject GateIn services in a Juzu application, this is now trivial to do and is explained in the wiki.

For the future we plan to develop new features and improve step by step the project, on top of my mind the integration with Bean Validation would be a good thing to do. If you are interested to follow the Juzu project development you can join our Juzu group.

Juzu Web Framework

2011-10-31T00:00:00-07:00

Juzu is an open source web framework I started to work on recently, for several reasons, the most important one is that there is no decent framework for developing portlet application in a simple and productive manner. There are other good and valid reasons.

Juzu deploys on the GateIn Portal and on the Liferay Portal. Perhaps it also deploys on other portals, there aren’t any good reason why Juzu would not work on other portal (except bugs).

Juzu integrates with dependency injection frameworks such as Weld (CDI) and Spring, theoretically it should work with any injection framework providing a good support of the JSR-330 specification (however it requires some custom integration work, as JSR-330 is really lightweight…)

Juzu is a work in progress, however it is advanced enough to deliver the infamous Booking application.

If you are interested in Juzu (using or helping), you can start to read this page.

CRaSH gets an installer!

2011-08-16T00:00:00-07:00

CRaSH 1.0.0-beta22 release features an IZPack installer that will let you configure a CRaSH runtime throughout a serie of screens, here is a short video showing an installation:

You can download them from the usual page.

GateIn 3.2 M1

2011-06-27T00:00:00-07:00

We released last week the first milestone of GateIn 3.2, it was a long time since the 3.1 release and both Red Hat and eXo teams were quite busy working on the product and project side of GateIn.

Among the noticeable changes, you will find now a support for Jetty 6.1/Tomcat 7/JBoss AS 6 web containers, a improved Maven build compatible with Maven 3, a few UI improvements and many bug fixes. You can read more about it there.

I’m proud now to work with Bolek that will replace Thomas Heute as GateIn technical lead. Bolek was involved in the effort since the JBoss Portal projects and earned his credits by providing an Hibernate implementation of the now dead Slide project (JCR ancestor) and implementing much of the Portlet 1 TCK assertions in our testsuite (that proved to be invaluable when JSR 286 was implemented). He blogged about his new role in the project here.

If you are a fan of GateIn, the CRaSH shell is a must have companion for GateIn. CRaSH is a shell that provides a JCR access and allows to do stuff and hack GateIn. Use it at your own risks of course ;-) . Download of the latest beta-21 is here.

Finally it’s time of a few words about GateIn stuff that is another GateIn companion I started a few months ago on GitHub. It’s something more informal than a real project, it’s like a bunch of stuff that could be useful if you’re a GateIn user, at least it’s useful to me, it contains so far:

a CRaSH folder with command for adding users to GateIn
gen : an XML generator for generating large navigations
sqlman : a tool based on the great JBoss Byteman project that measures the access to resources, very valuable for monitoring database activity. Note that this tool is generic and does not depend on GateIn itself. We could extract it and find a better name (containing “spy”)

Yet another CRaSH beta (21)

2011-06-08T00:00:00-07:00

Nothing fancy, in it, mostly bug fixes (in particular for SCP CRASH-23 and CRASH-24).

I updated also the Google Code page to add links to GitHub where the project is now hosted and the online docs now have the PDF and the Javadoc.

Finally the project CI is now Jenkins hosted by my friends at Cloudbees. A special thanks to Arnaud for helping me setting this up.

The release is available on Google Code as usual.

CRaSH update

2011-04-29T00:00:00-07:00

A long time since I haven’t blogged and released a CRaSH version (beta15), here are the the new stuff in CRaSH since the beta15 release.

First and foremost, the beta 20 was just released, so grab it, it’s very hot!

One of the most important feature is a new set of annotations for writing commands, that provides *contextual completion*! I think it was one of the most awaited CRaSH feature and now it is there, allowing for instance JCR path auto completion, but it works also based on the context and is able to provide completion for various part of the command line:

command: "sy" -> "system"
option names: "--fo" -> "--force"
enumerated values: "deb" -> "debug"
custom handlers, for instance JCR path: "/fo" -> "/foo"

Sub command is another neat new feature that allows to group several commands inside the same class, inspired from git:

log ls: list all loggers
log send: send a message to a logger
etc...

Here is an overview of how now CRaSh commands are written

New documentation system to provide usage and man for a command, further more now the command reference is included in the documentation

A few new based commands were addeddd

log: hot configure or send message to the logging system
jdbc: an out of the box SQL console for JNDI based datasources
system: interact with the VM properties

Finally we relocated CRaSH code on GitHub, the project page remains for now on Google Code along with the hosted documentation and downloads. It will allow to better follow the project status and contribute.

Uploading a file on Cloudreader iPad application from shell

2010-11-22T00:00:00-08:00

I’ve discovered the great Cloudreader application for iPad. Since I don’t have my books on the same computer than synchronize with my iPad, I’ve been using Cloudreader builtin capabilities for uploading my books. Unfortunately the web interface is rather poor and each file needs to be added separately.

So I went to write a shell script based on the curl command to perform a bulk upload to the Cloudreader server and I wanted to share it with other, here is the script:

#!/bin/bash

#Usage
if [ $# -lt 2 ]
then
  echo "Usage: $0 server_adress file1 ... fileN"
  exit 1
fi

#Save server and shift
UPLOAD_SERVER=$1
shift;

#Upload each file
while (( "$#" ))
do
if [ ! -f "$1" ]
then
  echo "The file $1 does not exist"
  exit 1
fi
echo "Uploading $1 on $UPLOAD_SERVER"
curl --form datafile=@"$1" --form title= --form author= http://$UPLOAD_SERVER/post >/dev/null
shift
done

CRaSH beta gets flexible command composition

2010-11-09T00:00:00-08:00

CRaSH 1.0.0-beta15 is just fresh out of the mill and gets an important new feature inspired from shell pipes.

We have added the capability to compose commands through the pipe (|) and the distribution (+) operators (if you find a more appropriate name, don’t hesitate to tell me).

I won’t detail the whole thing but instead give a few explanations, the whole thing is described in the documentation.

Each command is able to consume and produce a stream of node and this capability is described by a Java generic like notation : <C,P> with for consumed and

for produced. By default a command that does not specify anything is considered as <Void,Void>, i.e it does not consume and produce anything.

The pipe operator (|) allows to take the stream produced by a command and pipe it to a command that will consume it (<Void, X> | <X, Void>).

The distribution operator (+) is useful with the pipe operator and it allows to distribute a stream to two commands (<Void, X> | <X, Void> + <X, Void>) or to take the output stream of two commands and combine it in a single output stream (<Void, X> + <Void, X> | <X, Void>).

So after the nice theory, let’s see a few examples:

// delete all nt:file nodes
select * from nt:file | rm

// add the read permission to anyone on all nt:file or nt:resource nodes
select * from nt:file + select * from nt:resource | setperm -i any -a read

// change the mime type and encoding of all nt:resource nodes
select * from nt:resource | set jcr:mimeType text/html + set jcr:encoding UTF-8

In addition of this very nice feature, the war file packaging has been reworked to include less jar than before, those that were already bundled by the server runtime.

CRaSH 1.0.0-beta12 released

2010-10-06T00:00:00-07:00

We just release the 1.0.0-beta12 of CRaSH that add two new commands:

The addnode command adds one or several JCR nodes
The setperm command provides security configuration of JCR nodes

The rm command has also be improved and provides the capability to remove several nodes at the same time.

Aptvir the Java Compiler virus

2010-10-04T00:00:00-07:00

I’ve been using Annotation Processing Tools (APT) for a few months now, and I like it. It opens new capabilities for the Java platform, I exploited them to create an APT virus, called APTVir.

APTVir is a single class and a single file that replicate when it is available on the classpath n the compiled code. It relies on APT to execute itself and copy itself in the output produced by the compiler.

Instead of long explanations, I created a screencast that explains it :-) and the code is available as a GitHub repository.

Configuring easily a database for a JBoss AS cluster

2010-09-08T00:00:00-07:00

In GateIn project we sometime have to deal with the setup of a JBoss cluster. While JBoss clustering is quite easy to configure there are things you need to configure such as a shared database. In addition when doing tests you need to start from a fresh database. I will give you a tip I’m using when I’m setting up a GateIn cluster that can help you to save time for setting up a database.

By default GateIn uses the famous embedded database HSQLDB and it is very convenient because

Deployed with GateIn, no need for extra setup
Sufficient for doing development
Fast
Easy to erase the database and start from fresh

When dealing with a GateIn cluster (or any other application that requires a database), ultimately you need a database that will be used by the cluster nodes. Does it mean I have to give up HSQLSDB? the answer is no with an extra configuration step.

By default HSQLDB comes as an in process database, but it is possible to use other configuration modes:

Make the database open a port to accept remote connection
Connect to a remote database

We can use those two setup an asymmetric configuration of two nodes. The first node datasource owns the database and the second node datasource uses the database setup by the first node remotely.

CRaSH 1.0.0-beta10 release

2010-08-23T00:00:00-07:00

CRaSh 1.0.0-beta10 supports now line edition and cursor navigation for the telnet connector as its first contribution!

CRaSH 1.0.0-beta9 release

2010-07-08T00:00:00-07:00

CRaSh 1.0.0-beta9 minor feature and fix a few issues with GateIn 3.1:

export/import uses now the SSH username and password for accessing JCR for GateIn 3.1
connect now always require a password for GateIn 3.1
documentation now has a front cover page

enjoy!

Reflext improves its annotation introspection

2010-06-03T00:00:00-07:00

So far the annotation API in Reflext was using the runtime API to provide annotation access. What I call the runtime API is what most of developers are used to when dealing with annotations.

When using the java.lang.reflect runtime, this works perfectly as the runtime provides obviously runtime annotation. Nothing special here. However at compile time, this runtime access is emulated by the compiler. The real API to access an annotation is the java.lang.model.element.AnnotationMirror interface that is a totally detyped access to an annotation. But the APT tries to be nice and provides an emulation of runtime annotation that works well until

the introspected annotation is being compiled and it is not yet available under its class form
the annotation is already compiled (coming likely from JDK or a dependency) but it has a Class parameter and that class is being compiled. In that situation the Class object is not yet available, consequently it fails.

For that matter there is now in Reflext an API that provides a detyped access to an annotation that works equally with runtime and compile time implementations (runtime annotation access is still possible of course) .Using such API is obviously less intuitive than using the annotation directly but when you don’t have the guarantee that you are the annotation type is already compiled it’s the only way to go.

CRaSH 1.0.0 Beta 8 released

2010-05-27T00:00:00-07:00

We have just released CRaSH 1.0.0 Beta 8 on Google Code forge, in that release we have worked on two usability aspects of the shell:

The capability for a command to prompt a value with or without echo of the value entered by the user. It is mainly used by the connect command to prompt the password when it is not entered via the -p option.
The second feature is the up/down arrow associated to recalling previously entered commands.

The prompt command implementation required a refactor of the CRaSH architecture, the main challenge coming from the following facts:

the shell is invoked by a term and the term has blocking IO
the execution of a command needs to be interruptible

The refactoring was quite fun to do, and lead to a few improvements in the architecture that consisted mostly in decoupling the various systems, now we can distinguish:

The Shell that executes the commands and returns a result. The current implementation is connected to JCR to execute Groovy commands.
The Shell Connector, a state machine executing commands in a synchronous or asynchronous manner, it depends on its configuration. The execution of a command can be cancelled.
The Term: a state machine that translates IO into actions, managing also the command history.
The TermIO: the input/output of the Term, that is implemented using Apache SSHD and Wimpi TelnetD

At the moment I am quite satisfied by the current features. I think it is still missing the command completion and I don’t have a clue if it is easy or complex to do and which system should manage it, I’ll leave it for later fun. Maybe it will be easy to do, or it could require some new important refactor to make it possible to happen, who knows?

CRaSH 1.0.0-beta3 release

2010-02-16T00:00:00-08:00

Just released the 1.0.0-beta3 release of CRaSH, you can get it there.

The first and foremost new features in that release are contributed by Patrice Lamarque that gave us very important commands such as cp to copy a JCR node, mv to move a JCR node and xpath to perform an xpath query in a similar way you can perform a SQL query.

Beside that, the pwd command was bugged in beta2 and is fixed in beta3.

Chromattic support for embedded types

2010-02-08T00:00:00-08:00

The embbeded type support for Chromattic brings much power to object modeling on top of Java Content Repository that allows to fully take advantage of how JCR models node types. JCR type model provides two features that don’t match the Java type mode.

The first feature is multiple inheritance that is supported natively by JCR which allows a type to extend several super types. The other feature is the mixin support which is pretty much similar to multiple inheritance except that it can be dynamic, meaning that a node can be assigned with a mixin type. Conversely a mixin type can be removed from a node.

Both features are difficult with classic Java inheritance and the most appropriate way for modeling those is to leverage object delegation. Actually often object delegation is preferable over inheritance as it decouples the object types and provides support for dynamicity.

Mixin type support

The following example is taken from GateIn and it shows how several java type can support templatization with the embedded support. The Templatized class is a delegate object that provides a relationship to a Template type.

@MixinType(name="templatized")
public abstract class Templatized {

  @OneToMany(type=RelationshipType.PATH)
  @MappedBy("template")
  public abstract Template getTemplate();
  public abstract void setTemplate(Template template);

}

The Page class has an embedded relationship with a Templatized type.

@PrimaryType(name="page")
public abstract class Page {

  // Returns null if the mixin is not present
  @OneToOne(type=RelationshipType.EMBEDDED)
  public abstract Templatized getTemplatized();

  // Controls the life cycle of the mixin
  public abstract void setTemplatized(Templatized templatized);
}

At runtime this would likely be used in the following manner:

Page page = session.findByPath(Page.class, "page");
Templatized templatized = session.create(Templatized.class);
page.setTemplatized(templatized);
Template template = session.findByPath("template");
templatized.setTemplate(template);

Primary type support

Likewise Chromattic supports primary type, the only difference is that the dynamicity aspect does not occur therefore the relationship always exists between the types and it is obviously not possible to destroy it. This feature provides to my opinion a very good alternative for reusability.

Supports in GateIn

The embedded type feature has been added for GateIn in order to allow the Model Object for Portal (MOP). Indeed the model itself does not care about certain aspects and the portal needs to be able to make the base model richer than it is. With the embedded type we have the opportunity to keep the base model simple and have GateIn add its own mixins such as security, templatization, etc… Likewise eXo WCM that is built on top of GateIn will be able to add its own mixins for the purpose of web content management.

CRaSH 1.0.0 Beta 2 release

2010-01-08T00:00:00-08:00

The CRaSH 1.0.0 Beta 2 has been released, you can download it there and the documentation has been updated with the new features.

The most important feature brought by that release is the brand new support for SSH thanks to the Apache SSHD project. SSH access is more suitable for remote access on public networks and SCP can be used to import or export content from the repository.

Configuration is now possible via the web.xml file and the following can be configured:

SSH username, password, port and key file

Telnet port

Finally good work has been made on the release process by creating an archive containing the shell war file, the project sources and the javadocs.

Self-bounding Visitor

2010-01-05T00:00:00-08:00

I came across the generics self-bounding pattern, thanks to Olivier’s blog [in french] that uses it to describe fluent extensible interfaces. After a bit of research I found a very interesting forum thread that was talking about that pattern more in depth, in particular how it is possible to extend the pattern to a couple of classes.

Let’s just start with a simple example, a binary tree class:

abstract class Node<E extends Node<E>> {
   public E left;
   public E right;
}

class FooNode extends Node<FooNode> {
}

class BarNode extends FooNode {
}

class JuuNode extends Node<JuuNode> {
}

With that design, we constraint the Node class to be subclasses and have its children to be a subclass of its own subclass, and now we can write:

FooNode root = new FooNode();
root.left = new FooNode();
root.right = new BarNode();

But that is not possible:

FooNode root = new FooNode();
root.left = new JuuNode();

If you have carefully read the forum thread, someone posted an interesting extension of the pattern that uses two classes.

The Reflext framework I started to write a few months ago was using a visitor pattern to visit a set of types. There are several ways to visit a set of types, one of them is to visit the class hierarchy of super classes and implemented interfaces. There are many ways to implement the visitor pattern, one of them relies on decoupling the visitor from the code (or strategy) that takes care of doing the visit. The main interest is to reuse the visiting strategy many times and avoid the visitor to care about how visit is done, the visitor only cares about the overall strategy.

Based on this assumption, we can define two interfaces named Visitor and VisitorStrategy that will vary together, as it makes sense to use a hierarchy visitor with the hierarchy visitor strategy. Let’s start with the base interfaces. We use it a Type object as visited object, in the reflext framework it’s a TypeInfo interface that represents a type (which can be either runtime reflection or APT compile time reflection).

interface Visitor<V extends Visitor<V,S>, S extends Strategy<V,S>> {
  // The interface is empty as the base visitor does not provide an API
}

interface Strategy<V extends Visitor<V,S>, S extends Strategy<V,S>> {
  void visit(Type type, V visitor);
}

Now we can define the hierarchy visitor and its strategy

interface HierarchyVisitor<T extends HierarchyVisitor<T>> extends
  Visitor<T, HierarchyStrategy<T>> {

  // The API for hierarchy visit
  void enter(Type type);
  void leave(Type type);
}

abstract class HierarchyStrategy<T extends HierarchyVisitor<T>> extends
  Strategy<T, HierarchyStrategy<T>> {
  public void visit(Type type, T visitor) {

    // We only accept type which are java classes
    if (type instanceof Class) {
      if (accept(type)) {

        // Visitor callback
        enter(type);

        // Now visit the super class if we have one
        Class clazz = (Class)type;
        Class superClazz = clazz.getSuperClass();
        if (superClazz != null) {
          visit(superClazz, visitor);
        }

        // And now visit the interfaces
        for (Class itf : clazz.getInterfaces()) {
          visit(itf);
        }

        // Visitor callback
        leave(type);
      }
    }
  }
  
  abstract boolean accept(Type type);
}

We can see that the hierarchy visitor and its strategy vary together because they are constrained by design. The last piece missing is the to make vary the strategy (otherwise we would make the visitor and its strategy the same class…). We do it via an enum that provides several strategies

enum HierarchyScope {
  ALL() {
    public <T extends HierarchyVisitor<T>> HierarchyStrategy<T> get() {
      return new HierarchyStrategy<T>() {
        public boolean accept(Type type) {
          return true;
        }
      }
    }
  },

  ANCESTORS() {
    public <T extends HierarchyVisitor<T>> HierarchyStrategy<T> get() {
      return new VisitorStrategy<T>() {
        public boolean accept(Type type) {
          return (type instanceof Class) && !((Class)type).isInterface());
        }
      }
    }
  };

  public abstract <T extends HierarchyVisitor<T>> HierarchyStrategy<T> get();

}

Et voilà, now we can use safely the visitor. I’m not convinced that is a great piece of software, I’m just sure that it was very fun to write and research. Without the mentioned blogs and my favorite IDE (Intellij IDEA) it would have been nearly impossible to write correctly :-).

Self-bounding generics is a curious beast, it’s even called there “That Recursive Java Generics Thing”. Have fun!

GateIn management

2009-12-30T00:00:00-08:00

At the beginning of the year I started to write management capabilities in eXo Portal. It already had some management features but it was not really in a usable shape, it was indeed exposing every service of the kernel on the JMX registry, which was very confusing because it was exposing too much information and not the right information, it was just not usable.

Usability is word that matter, even in management, so my idea was, let’s expose management in a usable way. So I went on designing a way to expose management information based on Java annotations (well it’s pretty obvious to do that isn’t it?).

An important point was also to not tie the management to JMX. Indeed even if JMX is the kind of standard for exposing management in Java, I wanted to be able to expose the same management interface using Rest. The idea is to leverage the gadget server of GateIn and provide management information to gadgets.

So I went on designing the management contract (Java 5 annotations) that are agnostic of the management layer. Of course this is not enough for exposing the management in JMX nor in Rest. So we do have custom JMX annotations that describe how a management interface should be exposed in the JMX registry.

Here is an example of a managed service:

@Managed
@NameTemplate({@Property(key = "service", value = "cache"),
@Property(key = "name", value = "{Name}")})
@ManagedDescription("The Cache")
public interface Cache

   @Managed
   @ManagedName("Name")
   @ManagedDescription("The cache name")
   public String getName();

   @Managed
   @ManagedDescription("Evict all entries of the cache")
   public void clearCache();

   ...

}

The @Managed, @ManagedName and @ManagedDescription are the agnostic annotations. The @NameTemplate is an annotation that has only a sense for the JMX layer. The @Managed* annotations really focus on giving a clear and non programmatic description of the management interface.

There a few more features in the framework such an @ManagedBy annotation to specify a delegate for management interface to avoid to clutter the service with management, a ManagementAware interface for programmatically registering new managed object, a management context facility for correctly scoping managed resources (so several instances of the same service can be registered several times with different names in a transparent manner).

Recently I spent time to develop in the kernel layer the plugability for management provider. It is still in the trunk so nothing is really commited yet in GateIn. This plugability allowed my to write the Rest management provider in GateIn. It was also a good way for me to learn a bit more about JAX-RS (many thanks to Stephane that came a few weeks ago at the Mars JUG to talk about Rest and also for helping me a bit tonight :-) ). So I’m still not yet a Rest expert but I have a few bits of management stuff coming to Rest:

@Managed
@NameTemplate({@Property(key = "service", value = "cache"),
@Property(key = "name", value = "{Name}")})
@ManagedDescription("Exo Cache")
@Rest("cache")
public interface Cache
{
   ...
}

The @Rest (it’s not yet definitive) expose the management interface on the Rest connector. For now I’m only considering JSON in my experiment. The good news is that we have already plenty of useful management interface in GateIn that were developed a few months ago by our team and all those will be soon available via Rest!!!

CRaSH 1.0.0-beta1 release

2009-12-22T00:00:00-08:00

I’m glad to announce the release of CRaSH 1.0.0-beta1!!!

But wait, what is CRaSH?

CRaSH is a shell for Java Content Repository that allows remote connection to a server and performs various operations such as browsing and interacting with the repository, executing queries, performing import/export operations. You can read a complete introduction here.

As a GateIn developer I often use the underlying JCR engine and I developed CRaSH as a companion for my development tasks.

The project is written in Java and Groovy and leverages a few good open source projects:

The command system is written in Groovy allowing seamless extension of the shell by adding new commands
Netty provides the remote connection capabilities
Args4j parses the command line and inject the option and argument in the Groovy commands

It comes as a war file that setup a telnet daemon on the port 5000.

The project is developed on Google Code under the LGPL license and contributions are welcome :-) !

Inauguration du Mars JUG

2009-10-07T00:00:00-07:00

Le Mars JUG fera son inauguration le jeudi 15 octobre 2009 lors de l’Agile Tour.

Emmanuel Bernard a accepté d’être le parrain du JUG et cela nous fait très plaisir, il sera aussi le premier conférencier du JUG et nous parlera d’Hibernate Search, un projet qui permet de faire des requetes full-texte tout en utilisant Hibernate. Il explorera entre autre comment les recherches approximatives telles que la recherche phonetique sont implementées.

Les passionnés d’Agilité et de Java seront comblés car le JUG s’est associé à l’Agile Tour (participation gratuite, inscription ici) pour l’inauguration. Le but est de créer une synergie entre les deux évènements qui sont en général assez rare dans la région PACA. Je tiens à remercier Viaxoft et plus particulièrement Karine pour cette collaboration.

Dimitri Rodolphe Baeli un collègue d’eXo Platform sera lui présent mais durant l’Agile Tour pour faire un tour des pratiques TDD en entreprise.

Le but du Mars JUG est de fédérer autour de Java et de créer une communauté dans notre région, j’espère que vous répondrez présent à l’appel le 15 octobre.

Type Safe Enumeration with Java Generics

2009-07-28T00:00:00-07:00

I’ve been working with Java 5 Generics for about one year now and one pattern that emerged from my experience is the use of generics to create enumerations that provide type safety (I don’t claim to be the inventor of that pattern, actually I don’t even claim it is a pattern).

Often type safety can be achieved by using method type variables like

public abstract <N extends Number> createNumber(
	Class<? extends N> numberType,
	String stringValue);

The drawback of this solution is that all the classes must belong to the same hierarchy, in that example they all need to be a subclass of java.lang.Number. The most direct workaround is to free the type variable from its upper bound java.lang.Number. That makes the choice very large since any subclass of java.lang.Object can be accepted.

It is also impossible to prevent some subclass to be used as type argument at compilation time. Failure would have to happen at runtime with an java.lang.IllegalArgumentException thrown for instance.

Those two limitations makes the method not easy to understand the first time you see it, specially when it is part of an API, and it is not possible to make it type safe (actually not as far as I know :-) ) as Java Enums cannot be used as a generic declaration.

So I had to find a way to express an enumerated type that would be type safe. The solution I found is actually not an enumeration in the old/classic way we use to know it before Java 5 Enums (i.e it is class that has a private constructor with public static fields) and therefore it cannot be used in a switch statement. That probably is the only drawback I found but it is a more acceptable issue than the two problems I had before.

Let’s assume we represent a concept of simple types which are arbitrarily defined by String, Boolean and Integer with

public class SimpleType<S> {

   public static final SimpleType<String> STRING =
      new SimpleType<String>(String.class);

   public static final SimpleType<Integer> INTEGER =
      new SimpleType<Integer>(Integer.class);

   public static final SimpleType<Boolean> BOOLEAN =
      new SimpleType<Boolean>(Boolean.class);

   private final Class<S> javaType;

   private SimpleType(Class<S> javaType) {
      this.javaType = javaType;
   }
}

Now we can easily use it as a type safe enumeration, for instance here is how I would write a parse method:

/*
 * Note : yeah this is not really OO and it could be
 * possible to have an abstract parse(String s)
 * method on the SimpleType class and have the static
 * method delegate to it. I leave it as an exercise
 * for the reader.
 */
public <T> T parse(SimpleType<T> simpleType, String s) throws NullPointerException {
   if (simpleType == null)
      throw new NullPointerException("No null simple type is accepted!");
   if (s == null)
      throw new NullPointerException("No null string can be parsed!");
   if (simpleType == SimpleType.STRING)
      return s;
   if (simpleType == SimpleType.INTEGER)
      return Integer.valueOf(s);
   if (simpleType == SimpleType.BOOLEAN)
      return Boolean.valueOf(s);
   throw new AssertionError("impossible!);
}

This way we enforce the set of types that can be passed as arguments in our method and we do it in a manner that will enforce the developer to write type safe code.

Next time I’ll show you have it is possible to improve the pattern efficiency and usability by adding methods on the Type Safe Enumeration class.

Advanced Java reflection framework needs a (good enough) name

2009-07-17T00:00:00-07:00

I have been working during the past few days on a reflection framework for Java. Beside the complexity of the actual reflection layer, the developer is pretty much left to himself to perform advanced operations such as type variable resolution or annotation discovery based on the type inheritance hierarchy.

Furthermore this reflection framework is implemented with the runtime java reflection API (java.lang.reflect.Type and its implementations) and the compile time java reflection API (javax.lang.model.type.*). It means you can perform compile time reflection or runtime reflection with the same code. I forgot to mention that the java compile time API is awful.

The first reason I wrote this framework was to perform type variable resolution based on a specific class. I needed to perform such operations for a new project (that I will announce soon, stay tuned).

Let me give you an example:

public class A<V> {

  private final V value;

  public A(V value) {
    this.value = value;
  }

  public V getValue() {
    return value;
  }

public class B extends A<String> {
  public B(String value) {
    super(value);
  }
}

Now if we want to know what is the value of the type variable V at runtime for the class B, the code to perform the resolution is pretty tricky to write and requires a fairly good knowledge of the java type system, although it’s a very intuitive operation to do. Let me give you another example:

public class Event<S> {

  private S source;

  public Event(S source) {
    this.source = source;
  }

  public S getSource() {
    return source;
  }
}

public interface Listener<S> {

  void onEvent(Event<S> event);
}

public class FooListener implements Listener<String> {
  void onEvent(Event<String> event);
}

Although we all know that Java type erasure will not give us the type of S at runtime from instances of the Event class, any implementation of the Listener interface will carry the information about the type variable. Note that it may not be possible to resolve it if the subclass does not bind the variable to a type. It is therefore possible for the framework broadcasting events to know if a listener is able to receive events from a particular source.

Since Java 6 it becomes very easy to process source code at compile time (as exhibited by Gavin King during his researches about the type safe criteria API for JPA). For instance it would be possible to replace the need for CGLib at runtime by a library that would perform a similar work at compile time (actually I wrote pretty much that in the forthcoming project). The advanced Java reflection framework helps to hide the java compile time reflection API. The compile time API is source code oriented but does expose the same semantics as the runtime API.

Another neat feature is the resolution of annotations along a type hierarchy which is very useful if you want to determine the annotation of a type or a method taking in account the type hierarchy. Very useful in the following situation

@Foo
public interface A {
  @Bar void m();
}

public class B implements A {
  public void m() {
  }
}

Finally the framework has some nice stuff coming in, such as the inclusion of the visitor pattern that allows you to perform an operation along the hierarchy of a type, the obtention of the raw class type of any type which attempts to unify the raw type of a parameterized type and the elimination of the synthetic methods due to the return type covariance.

I plan to host that reflection framework project soon somewhere (under LGPL) because I think it will be useful to anyone performing advanced operations with the Java reflection. What is missing for now is a decent name for the project since I haven’t been able to come up with something nice. If you have a good suggestion, don’t hesitate to send me an email (go on www.julienviet.com for the @).

Marseille JUG au BarCamp Marseille 2!

2009-04-19T00:00:00-07:00

Vendredi 7 avril j’ai participé au BarCamp Marseille 2 pour promouvoir la création du Marseille JUG.

Les évènements orientés nouvelles technologies sont plutot rares sur Marseille et c’est ma première participation à un BarCamp. A vrai dire je ne connaissais pas ce concept avant cette occasion dont j’ai connu l’existence via le Twit de Charles, rencontré de visu justement durant l’occasion.

L’école d’ingénieur Supinfo Marseille hébergeait le BarCamp pour l’occasion ce qui m’a donné l’occasion de visiter les docks qui ont été rénovés il y a quelques années. J’avais déjà visité un peu les docks et j’ai constaté que l’intérieur des batiments est aussi beau que l’aspect extérieur le laisse penser.

A présent, venons en aux faits! furent présents lors de la réunion:

Alain Defrance formateur Java à Supinfo
Yann Vigara revenu de Paris il y a quelques mois et qui démarre une activité d’hébergeur Java
Alexandre Terasson et Florien Berton élèves à Supinfo
Cyril Bourgès étudiant en master SIS de Luminy
Moi même

La réunion a d’abord commencé par les cordialités d’usage à savoir la présentation de chacun des participants.

Il faut savoir que notre aventure du Marseille JUG a débuté il y a quelques semaines. Khaled, Colin, Alain et moi même nous sommes déjà rencontré plusieurs fois avant le BarCamp (malheureusement Khaled et Colin n’ont pas pu participer au meeting BarCamp). Nous avions donc déjà donné une direction au JUG et cela a été l’occasion d’exposer nos décisions. Je rassure tout de même, celles ci sont assez standard et nous n’auront pas une gouvernance basée sur le totalitarisme, en fait la plupart d’entre elles émargent de la lecture de la mailing list des JUG leaders français. Voici donc les points que nous avons discutés:

Direction collégiale avec des status basés sur la notion de co présidents. Cela nous est apparu comme le mode idéal et a suggéré par un JUG ayant ce mode de gouvernance
Volonté de faire une réunion unique avant fin juin 2009 et mise en place d’un calendrier de réunions pour la saison 2009/2010
Recherche de partenaires et de sponsors financiers pour aider le JUG

Il apparaît que Supinfo fournira un partenariat afin que le JUG puisse profiter des locaux de l’école. Ceux ci semblent idéaux car modernes et avec une position géographique très avantageante. Nous souhaiterions effectuer une réunion mensuelle du JUG, vraisemblablement le mercredi qui est un jour où nous pourrions utiliser la salle aussi bien l’après midi que le soir (probablement 18h).

Finalement nous avons conclu qu’à présent la prochaine action à effectuer est de s’occuper de tout le travail administratif qui fondera le JUG en tant qu’assocation 1901. Ceci est un mal plus que nécéssaire pour la création du JUG.

Longue vie au Marseille JUG!

2009-04-03T00:00:00-07:00

Le Riviera JUG organise sa deuxième rencontre le 10 avril sur le theme SOA, si vous êtes intéressé vous trouverez plus d’information sur cette page.

Marseille JUG

2009-04-02T00:00:00-07:00

Depuis quelques mois une folie créatrice de groupes d’utilisateurs Java (JUG) envahit la France et un JUG se monte naturellement dans la région de Marseille. Si vous êtes intéressé de quelque manière que ce soit, vous pouvez prendre contact avec l’équipe du JUG.

How to mount a remote AFP drive on AppleTV Take Two

2009-01-11T00:00:00-08:00

I suppose that you have already installed NitoTV on your AppleTV as you need it to get remote drive access (note that it’s probably possible to do without it by doing everything through SSH).

The AppleTV with a native firmware above 2.0, does not have the AFP protocol in its recovery partition. So even though you upload the MacOSXUpdCombo10.4.9Intel.dmg on the AppleTV and create the recovery.dmg it will not give you access to the AFP protocol. The main reason is that the recovery.dmg image does not contain it! But if you would have an AppleTV with a 1.0 firmware it would have worked since it’s still in the recovery partition (it makes sense, doesn’t it) ?

Someone found a solution to workaround this issue, and I think it’s interesting to blog about it, since it’s in a forum post on the atvflash forums (it’s also like a note to myself, in case the post would disappear). So here is verbatim the solution:

Do a factory restore of the ATV, update the firmware to the latest version and then run the patchstick again. You may be able to uninstall NitoTV but I couldn’t get this to work after a failed smart installer attempt. A freshly hacked box seems to be the most reliable method.
On ATV: SSH in with terminal and enter @sudo dd if=/dev/disk0s2 of=recovery2.dmg bs=1m@
This makes a recovery image of your Take 2 recovery partition.
On the Mac: sFTP into the ATV, I used an app called Fugu to do this, and download recovery2.dmg to your desktop.
On the Mac: Open recovery2.dmg. Once it’s mounted you’ll see a number of files in there but the one we’re interested in is called “OS.dmg”. Rename this to anything you want.
On the Mac: Copy in the 1.0 recovery image you have managed to obtain. Mine was called OS-dot-DMG 1.0.dmg and the md5 = 55b909196952ff72c93aaf3553cf661e
On the Mac: Rename the image file you have just copied to “OS.dmg” and then unmount recovery2.dmg. You will now have an image of your ATV’s recovery partition called recovery2.dmg but the OS.dmg file contained within has been replaced with the 1.0 version.
On the Mac: sFTP into the ATV and upload the edited recovery2.dmg to the Documents folder. Then rename this file recovery.dmg
On the Mac: sFTP into the ATV and upload MacOSXUpdCombo10.4.9Intel.dmg to the Documents folder.
On ATV: With the remote navigate to the DVD/NitoTV menu and select Settings > Install Software. I then ran ‘Install Perian’, ‘Install mPlayer Codecs’ and ‘Install Turbo’s kextloader’ in that order. This probably wasn’t necessary and most of it is probably already there but worth doing just to be safe.
On ATV: Once all this is done you’re ready to run smart installer.
Unplug the ATV, plug it back in and then you should be able to mount the box on your mac and see your shares on the ATV. I’ve found that streaming video from your Mac via afp in NitoTv/DVD is a bit choppy. Streaming through the “Files” menu seems much smoother.

The only thing I need to add is that the so called “OS-dot-DMG 1.0.dmg” is the original firmware of the AppleTV that you can obtain if you own an AppleTV Take One.

The original forum post can be found here and all the credits go to Scrubadub and Magic, whoever you are.

Nikon D80 HDR bracketing tutorial

2009-01-06T00:00:00-08:00

Recently I dived into High Dynamic Range photography (also known as HDR) using my Nikon D80.

My interest for the HDR technology is the capability to produce images that would be almost impossible to take with a digital camera. An HDR image reveals details in the light and dark areas of your images.

For instance, on this picture we can see the details in the clouds but also on the rock and it would be very hard to achieve it without HDR.

This tutorial does not explain how to create an HDR image because there are already very good tutorials on that subject, for instance you can read Vanilla Days tutorial, it is based on the Photomatix software but it does not hurt and you could use another software.

I will rather focus on explaining how to configure a Nikon D80 to leverage a built in feature called Auto Exposure Bracketing (AEB) that makes easier the creation of HDR images. I found all the relevant informations in the user manual but they were not clear enough and I had to spend some time on it in order to get it effective.

HDR imaging works by combining the same image with different exposures into a single image using an appropriate software. No need to emphasis on the fact that the images should rigorously be the same as possible. It can be done manually by shooting several times the same pictures with different exposure time and keeping the same aperture size, but it has at least two drawbacks:

you need to physically touch the camera to change the exposure and it could change slightly the different images
it take time to reconfigure the camera and your image may change during that time (clouds may move for instance)

The Nikon D80 has a feature called bracketing that allows to shoot three times the same pictures with the same aperture but with different exposures in that order:

The normal image
The underexposed image
The overexposed image

Here is my howto for configuring the D80 appropriately:

Configure the image quality

The first step is to set the image quality to RAW. You can change it by pressing the QUAL button and rotate the the main command until you get RAW.

Configure the ISO sensitivity

Set the ISO sensitivity to the lowest value you can afford, for instance ISO 100 works well most of the time for me.

Configure the focus mode

Focus mode should be configured to manual (perhaps it’s possible to use automatic but I never tried).

Configure the mode

Set the D80 into Aperture-priority mode (A). Exposure bracketing works with that mode.

Configure the bracketing

Press the BKT button and rotate the main dial to chose 3 shoots and the sub-command dial to choose the bracketing increment with the value 2.0EV. At this moment you configured the D80 to change the exposure of the photo each time you shoot. Therefore the first picture you take is a normal one, but the second one will be underexposed by 2EV and the third one will be overexposed by 2EV. The forth one will be exposed normally.

Configure the shooting mode

The final step is to configure the shooting mode to continuous.

Et voilà!

The next time you will take a picture keep the finder pressed and the D80 will take the three shoots for you. Now it’s up to you to make great HDR pictures!

I'll be at Devoxx 08

2008-12-08T00:00:00-08:00

Long time no blog, just a quick note that tell you that I will be at Devoxx 08 as a representative of eXo in the exhibition center.

See you there!

The WebOS Vision

2008-10-15T00:00:00-07:00

The initial vision

When I was a JBoss contributor, we used to name the infrastructure kernel as WebOS, it was Marc Fleury’s vision I think. Actually for many years the banner of our source code was:

/*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/

It may sound a bit marketingish but it is a simple and powerful concept that was pioneered by JBoss in 2000 and followed by a large crowed since then. The fundamental idea is to provide a system for managing services. That system can be simplified as the equation WebOS = deployer + registry + controller , I won’t go farther in the gory details. Today JBoss as rewritten from scratch the system as JBoss Microcontainer, we assume that it is as of today the most complete system and will be for many years.

So JBoss Microcontainer provides a runtime for your services, do you think it is sufficient ? that would surely work out if you would use services the way we used computers 30 years ago (or maybe 40) with a shell as unique user interface.

Toward a more complete vision

To complete the picture we need an infrastructure to deliver an user interface that is adapted to the web and that’s our business at eXo. What we provide can be simplified as @WebOS = deployer + registry + aggregation + identity@.

The deployer takes care of deploying visual components such as portlets or widgets. Both are connected to your service infrastructure but in a different manner. Portlet adapts your existing applications (JSF, Tapestry, Struts, et…) to the portal world. Widgets are more stateless and access services through Rest. Components are registered in the registry. Nothing really fancy here.

The aggregator and identity are the real value add

The aggregator provides rich front end capabilities to deliver the user interface adapted to your needs based on flexible layouts and skinning. the Ajax technology came to the rescue a few years ago and is now naturally involved to improve the end user experience. It comes in two flavors, the classic portal and the WebOS portal (here literally an operating system like OS X or Vista).

The identity part takes care of linking your existing user back-end to the portal. It integrates the profile and the various roles of the user (I am not talking here about the social aspect of the user identity as it is out of scope of this blog, we’ll have more announcements about that soon).

The vision

The vision we have sketched so far is almost complete. Our WebOS is able to deliver services and applications to your users, but it comes as an empty shell. To make it more sexy it would be nice to have applications to deploy in it. It is also what eXo delivers as professional and powerful application products that comes bundled with our offering providing a full fledged WebOS solution.

What's new and cool in Portlet 2.0

2008-09-18T00:00:00-07:00

I just made my presentation available on SlideShare!

Portlet 2.0 @ JavaZone 2008 18th of September

2008-09-08T00:00:00-07:00

I will be speaking next week at JavaZone 2008 about Portlet 2.0 aka JSR 286. The talk title is “What’s new and cool in Portlet 2.0″ and it’s about the new features in the JSR 286 specification. I’ll introduce the new key features of the spec with demonstrations.

My session is on Thursday 18th of September 2008 at 3:45 pm. You can find more information on that page. I’ll be there during the full event so if you want to meet and have a drink, it will be with great pleasure.

The future is so bright...

2008-09-05T00:00:00-07:00

…that I almost need my shades.

eXo Platform SAS announced officially today that I am now part of the eXo Platform crew as Portal Product Manager.

Massive mail import in GMail

2008-08-25T00:00:00-07:00

Recently I had to archive a consequent number of mails into GMail. I don’t want to keep those mails in my Mail User Agent (Mail.app), yet I want to be able to search and retrieve any single mail. Of course I’m keeping an mbox version of those mails but once it’s in an mbox, it’s kind of dead because you cannot easily read one mail or search the mbox.

I considered several solutions and the simplest I could find is to dedicate one GMail account for that purpose. The only drawback is to have internet access but I’m fine with that. In addition the IMAP support provided by GMail allows to do that without any hacks.

Once my special GMail account was created, I started to use my mail client to copy the messages in dedicated folders in the archive account. It was working fine for a small number of messages like 5000. Some of my mailboxes have way more messages, like 60,000. Above 5000 messsages, it becomes a nightmare for two reasons:

The mail client synchronizes with the archive account which slows down the whole process.
Network failures are more likely to happen and make the whole process very fragile. When you have a network failure you don’t know how your mail client will hold the resume.

I started to look around for solutions but I did not find something that would work out well for me. So I started to create my own solution, that would just do the job. Obviously I used Java as it offers all the low level API and frameworks to build the solution:

JavaMail: the corner stone
JSR 166 Concurrency Utilities, the CompletionService which allows to multithread trivially the system and improve the import throughput
Mstor a local store provider for JavaMail: provides a way to read mbox format using the JavaMail API.

Then I wrote a few classes using the above frameworks to perform the massive import. It turns out to work very well and deals with network failures when it happens. I won’t make an open source project because I don’t have extra time to invest in that, however if someone is interested in getting the source code, I would give it as it is.

The footprint of the Air Ajax runtime

2008-08-21T00:00:00-07:00

When I started to use Spaz, I naturally twitted about it and of one my friends tried it. He recognized that the application was better than Twitterific but did not adopt Spaz because of the OS resources consumed by the application. I know a bit the heart of Spaz as I developped a few of its features, I know that it does not waste resources and I concluded that perhaps the runtime could be the cause of this overhead.

This morning, I downloaded one of the simplest applications written in Air Ajax, the classic Hello World application. I simply executed the application adl -nodebug application.xml and used the Activity Monitor utility provided by Apple to measure the memory and CPU footprint. The question is simple: what is the overhead of an application that nearly does nothing and have nearly zero state ? Note that I use the -nodebug switch which optimizes the runtime, thanks to Ed Finkler that gave me the hint. It helps to reduce the CPU used by the application by a factor of 2. The first version of this entry did not take it in account.

Disclaimer: this test is very subjective and if someone else performs the same test, he will likely find a different result.

The answer is pretty big for me. My machine is a MacBook Pro 2ghz with 2 gigs of RAM (I can’t have more because it’s one of the early models). The application uses constantly around 2% of CPU and 20 megs

It is way too much for desktops. I wondered then how does it scale if I run 10 times the same application ? Perhaps that Air has a smart runtime that can collocate resources ?

According to my results, running 10 Hello World application consumes around 200 megs of RAM and around 20% of my CPU. Clearly I see a problem here, how can the end user really uses several Air applications at the same time without consuming too much OS resources ?

That reminds me the story of the Java virtual machine. Back in 2000, the early versions of the Java virtual machine were slow and gradually they improved the performance of their virtual machine. If I remember correctly the JDK 1.4 was the first release to provide decent CPU performances and then each major release had seen decent performance boosts. BTW: Sun’s VM also uses lot of memory but the CPU footprint is nearly zero. Reducing memory overhead is not achieved yet, I know they have plans to collocate if you execute several virtual machine though, I am not an expert.

I hope that Air will follow the same path and that Adobe will invest in the optimisation of the runtime. In my opinion it is a key factor to increase the adoption of the platform.

Adobe Air for Ajax Developers review

2008-08-18T00:00:00-07:00

I have been playing recently quite often with the Adobe Air SDK for Ajax developers. For more than 10 years my focus has been mainly the Java Platform and I did not have to use anything else so far. Don’t misunderstand me, I won’t probably use much the Air in my job activities. My interest for it comes from the involvement in the Spaz project. Spaz is an open source Twitter client written for the Air runtime with the Ajax kit, the story is a very classic one, I was looking for a good Twitter application and after using Twitterific for a few days, finally I switched to Spaz. Spaz answered most of my needs and I was able to easily provide patches to add new features that I was considering as important to me.

The first thing I did was to install the Air SDK for Ajax development. Adobe provides several development runtimes and one of those is based on Web standards: HTML, CSS and Javascript. Once you have downloaded the kit, you need to set the AIR_HOME variable and add to your path the $AIR_HOME/bin expression.

After that you have access to the adl command that allows you to start an Air application. In the case of Spaz, I downloaded the source tree from the SVN and used adl application.xml et voilà! The application just start.

The main advantage of the Ajax runtime is to reduce the entry level for developers. I was already quite familiar with Web and Ajax technologies and Adobe had a great idea to create such a platform. (It helped me to understand better Sun strategy with the heavy promotion of the Java FX platform). Most of the objects you will use are wrappers of Actionscript 3.0 objects, if you look at the documentation you will find for instance that the air.desktop.Icon is an alias for the window.runtime.flash.desktop.Icon. Does the developer cares about that ? I would say yes, because the default wrapper set is partial and does not cover the full platform, therefore sometime you need to use window.runtime.flash.* when you want to access advanced features. It happened to me when I added a feature that display the number of unread message in the dock icon, pretty similar to what Mail.app does.

The platform seems powerful enough. However compared to the Java platform it’s very poor, but the main focus of the platform is to build RIAs and therefore it does not matter much. The integration with the desktop lets you leverage native menus, the dock icon on OS X and the system tray icon on Windows.

The documentation is the weak points of Air. The online API documentation is similar to Javadocs, so you will feel comfortable with it. The main issue comes from the main documentation that does not cover everything. The documentation for the embedded local SQL database is just minimal. When I developed the badge feature for the dock icon, I felt it was possible to leverage the powerful vector capabilities of Air to create nice shapes and indeed I was able to achieve it but as the cost of looking at the Actionscript 3.0 documentation which in my opinion is an issue (well even the Actionscript documentation was not enough) and I was left by myself.

Finally I find the platform powerful and simple, the main issue being the documentation. If you have good Web and Ajax skills you can leverage them to build quickly an application. The main advantage over traditional Ajax application is that you won’t be annoyed when doing cross domain Ajax, won’t have to deal with browser quirks and will create more powerful RIAs. If your Web and Ajax skills are poor, you should consider twice using that platform, but the learning cost in time and resource is not lost as you can reuse your knowledge for building classic Ajax application.

Syntax highlight support

2008-08-14T00:00:00-07:00

I’ve just added support for the syntax highlight using the very good project SyntaxHighlighter.

I used the WordPress plugin Google Syntax Highlighter for WordPress but not without pain.

Indeed there is a CSS conflict between SyntaxHighlighter and Wordpress at the list level that makes the highlighted code to be displayed with additional margins. If you want to see what I mean, download the plugin for WordPress and look at the screenshot. The plugin on my blog is fixed.

So now the fix: modify the file Styles/SyntaxHighlighter.css in the plugin (which originally comes from the SyntaxHighlighter project). Add the following at the bottom:

html > body .entry div.dp-highlighter li {
  margin:0px 0pt 0px 0px;
}

JSON support for WordPress

2008-08-14T00:00:00-07:00

I find quite strange that nobody ever provided support for that. Googling about JSON support for WordPress did not return anything relevant. At all.

I use the JSON support in my home page. It is used to display the last 5 blog entries of this blog in the side bar. It does not appear at first as I did not want to clutter the page, so you need to hover the mouse over the blog section and you will see it appear using a nice fading (thanks to jquery).

Anyway here is the php code for WordPress. It is not a plugin because it does not interract with the heart of the system and WordPress does not seem to have an architecture for adding that kind of feature. I believe it should rather be a core feature of the product rather than an extension.

First step, create a file called wp-json.php at the root of WordPress:

<?php
if (empty($wp)) {
	require_once('./wp-load.php');
	wp('feed=json');
}
require (ABSPATH . WPINC . '/feed-json.php');
?>

Then create a file named feed-json.php in the wp-includes folder:

<?php
header('Content-Type: application/json; charset=' . get_option('blog_charset'), true);
$more = 1;

$items = array();
query_posts("");
while (have_posts()) :
the_post();
$item = array(
	"title" => get_the_title_rss(),
	"link" => apply_filters('the_permalink_rss', get_permalink()),
	"description" => apply_filters('the_excerpt_rss', get_the_excerpt()));
$items[] = $item;
endwhile;

$arr = array(
'title' => get_bloginfo_rss('name'),
'link' => get_bloginfo_rss('url'),
'description' => get_bloginfo_rss('description'),
'language' => get_option('rss_language'),
'item' => $items);

echo "".$HTTP_GET_VARS["callback"]."(".json_encode($arr).");";
?>

Then the URL to use it is http://yourdomain/yourpath/wp-json.php?callback=myfunction. The callback is mandatory (if you don’t want it, modify the php script above) in order to make the feed mashable directly in a web page. It will return data like:

myfunction({
	"title":"It is what it is",
	"link":"http:\/\/blog.julienviet.com","description":"A pure technical trip",
	"language":"en", ...
});

I’ll explain later in another post how I consume it in my home page.

Unofficial launch

2008-08-13T00:00:00-07:00

This is the unofficial launch of my blog.

My home page went alive a few days ago and after that I’ve managed to install wordpress and customize it for my needs. Well almost, I still need to add the syntax highlighter plugin and do a couple of other things.

Working on my home page and the blog was a rich experience, actually I never really managed to do so called client side mashups and now I understand better what it is about. Thanks to javascript and JSON, I’ve been able to integrate Twitter and my blog feed into my home page without requiring any server side code. I did it that way for the sake of simplicity in term of development, as I’ve been able to work directly on the page without the need of any server. There’s a trade off though, doing that kind of mashup is not an easy task and requires considerable skills.

I still have a few things to tune in order to officially launch the blog/site and drink Champagne. For instance I may consider to change the default theme of the blog although it is quite nice, it obviously has a taste of déjà vu. Actually I am considering to pay someone to create a custom theme, but I would need to find the right person first.

I hope to open next Monday, see you next week!

Syntax highligher test

2008-08-13T00:00:00-07:00

Testing syntax highlighter plugin:

public class Hello
{
   public static main(String[] args)
   {
      System.out.println("Hello");
   }
}

function hello()
{
   alert('hello');
}

Julien Viet's blog

CRaSH 1.3 beta3

Polyglot

Improved Groovy support

Evaluating a command

Evaluating a compound command

Passing options and arguments

Command pipeline

Extended REPL

Asciidoc documentation

Wrap up

Devoxx University

CRaSH session

Out Of The Box

The Swiss Knife

Extend your runtime

Monitoring

Hackergarten

CRaSH at Devoxx 2012

CRaSH 1.1 release

Color and styles

Spring support

Standalone mode improvements

Download

Finally

CRaSH 1.1-cr1 released

Juzu 0.5 released!

Juzu has Mustache!

CRaSH feedback after Devoxx FR 2012

CRaSH 1.0 released

CRaSH Standalone

CRaSH 1.0 CR1

JSON to Java with JDK6

Juzu 0.4.2

Juzu Web Framework

CRaSH gets an installer!

GateIn 3.2 M1

Yet another CRaSH beta (21)

CRaSH update

Uploading a file on Cloudreader iPad application from shell

CRaSH beta gets flexible command composition

CRaSH 1.0.0-beta12 released

Aptvir the Java Compiler virus

Configuring easily a database for a JBoss AS cluster

CRaSH 1.0.0-beta10 release

CRaSH 1.0.0-beta9 release

Reflext improves its annotation introspection

CRaSH 1.0.0 Beta 8 released

CRaSH 1.0.0-beta3 release

Chromattic support for embedded types

Mixin type support

Primary type support

Supports in GateIn

CRaSH 1.0.0 Beta 2 release

Self-bounding Visitor

GateIn management

CRaSH 1.0.0-beta1 release

Inauguration du Mars JUG

Type Safe Enumeration with Java Generics

Advanced Java reflection framework needs a (good enough) name

Marseille JUG au BarCamp Marseille 2!

SoirÃ©e SOA au Riviera JUG le vendredi 10 avril 2009

Marseille JUG

How to mount a remote AFP drive on AppleTV Take Two

Nikon D80 HDR bracketing tutorial

Configure the image quality

Configure the ISO sensitivity

Configure the focus mode

Configure the mode

Configure the bracketing

Configure the shooting mode

Et voilà!

I'll be at Devoxx 08

The WebOS Vision

The initial vision

Toward a more complete vision

The aggregator and identity are the real value add

The vision

What's new and cool in Portlet 2.0

Portlet 2.0 @ JavaZone 2008 18th of September