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 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!

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:

• 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…)

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.

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 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.

You can download them from the usual page.

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”)

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.