The first release of Apache Sling is available. Please see Carsten Ziegeler's announcement on Sling's mailing list and on TheServerSide where a little discussion emerged.

Congratulations to the developers!

Have you ever wondered what is going on with the client requests sent toa Sling based application and what Sling is doing in the background so thatyou can worry about your primary job, the Web based application you arebuilding? Have you been tasked to find out, why your latest super Web basedapplication suffers from performance degradation from time to time?

In case you are tempted to answer the above questions with a firm yes Ithink you will be happy to hear that the days of implementing a tracker overand over again in each new project has gone. With Sling you get a trackerfor request processing for free and out of the box: The RequestProgressTracker.

Sling creates such a RequestProgressTracker instance for eachrequest being processed and also uses it to track various processing stepslike resource and servlet/script resolution. You may add your own logging andtracking to this instance and at the end of the request dump it either intoyour HTML response or have it written to the log file or to a real filesystemfile or to the JCR repository or wherever you like.

Functionality of the RequestProgressTracker

First things first: What can we do with this tracker ? This is a simple questionto answer. These are the API methods of the RequestProgressTracker:

• Logging simple and formatted messages. This is mainly used to mark some stateduring request processing. A message added to the internal log of messagestogether with a time stamp.
• Timing sections of request processing. Timing parts of request processingconsists of two steps: First you start a (named) timer before the part to betimed and after that part you log the timer by the same name.
• Get all messages. If you want to process the logged messages yourself, e.g.to write them to a file or the JCR repository.
• Dump all messages to a java.io.PrintWriter. If you just wantto add the request progress information to your generated HTML page as anHTML comment, for example.

Show Me an Example

Let's go. Let us explore a very simple example of just dumping the contentsof the tracker. First launch Sling - this can be as easy as just runningthe Sling Standaline Application you get from the Apache SlingDownloadspage.

After downloading and unpacking the Sling Standalone application, open a commandshell and change to the directory of the unpackedorg.apache.sling.launchpad.app-3-incubator.jar file and launchit with:

$ java -jar org.apache.sling.launchpad.app-3-incubator.jar -p 8888 -f -

The argument "-p 8888" instructs Sling to listen on port 8888. You maychange this to any free port you like. The default port is 8080. The argument"-f -" causes log messages to be written to the standard output. This isvery convenient for development. By default log messages go to thelogs/error.log file in the Sling Home directory (sling by default). Toget a list and short explanation on available command line options, use theparameter "-h".

Next connect Sling using WebDAV and create a folder /apps/sling/nonexistingand in that folder create a file GET.esp with the followingcontents:

<%response.setContentType("text/plain");response.setCharacterEncoding("UTF-8");request.requestProgressTracker.dump(response.writer);%>

Now in your browser request a resource which you know is not existing. For examplein a fresh installation of Sling, there is no resource at /missing.txt.So requesting that will give you the following response (line numbers added by theauthor):

 1:      0 (2008-06-18 10:18:26) Starting Request Processing 2:      0 (2008-06-18 10:18:26) Starting ResourceResolution 3:      0 (2008-06-18 10:18:26) URI=/missing.txt resolves to Resource=NonExistingResource, path=/missing.txt, elapsed = 0ms 4:      0 (2008-06-18 10:18:26) Starting ServletResolution 5:      0 (2008-06-18 10:18:26) Starting resolverServlet(NonExistingResource, path=/missing.txt) 6:      5 (2008-06-18 10:18:26) Using Servlet /apps/sling/nonexisting/GET.esp, elapsed = 5ms 7:      5 (2008-06-18 10:18:26) URI=/missing.txt handled by Servlet=Script /apps/sling/nonexisting/GET.esp, elapsed = 5ms 8:      5 (2008-06-18 10:18:26) Starting /apps/sling/nonexisting/GET.esp#0 9:     13 (2008-06-18 10:18:26) Dumping SlingRequestProgressTracker Entries, elapsed = 13ms

As you can see from this simple dump resolving the addressed resource tookan unmeasurable amount of time (0 milliseconds, line 3). Next you see, thatresolution of the script took another 5 milliseconds (line 7) and finallyrunning the script from the point of the call upto the point of requesting thedump used 8 milliseconds.

Further you see normal log entries like the one on line 9 and timer relatedmessages on the other lines: Lines 1, 2, 4, 5 and 8 marking timer starts and theother lines 3, 6 and 7 marking timing points.

You may notice that the timer "/apps/sling/nonexisting/GET.esp#0" is only dumpedwhen started but not when terminated. The reason for this is of course, thatthe timer is only logged when the script has finished but we dump the log beforethe script has terminated. Hence this log entry has not been added yet.

This example also shows you nicely how resource resolution and script resolutionwork hand-in-hand: The request to /missing.txt could not be resolvedto an actual JCR Node, so the resource resolver created a so-calledNonExistingResource whose resource type is set to sling:nonexisting.This resource type is then used to resolve the script /apps/sling/nonexisting/GET.esp. As you can see theresource sling:nonexisting type has been converted to the (relative) pathsling/nonexisting which is then used for the script resolution.

Log Dump Method

• dump(PrintWriter writer) -- Write all log messages to thegiven java.io.PrintWriter.

Logging Your Own Entries

The first example above contained only messages added by Sling itself, lets addsome messages of our own now into the log. To this avail we change theGET.esp script as follows:

<%request.requestProgressTracker.log("Starting Script Execution");request.requestProgressTracker.log("Script {0} of type {1}",        sling.script.scriptResource.path,        sling.script.scriptResource.getResourceType());response.setContentType("text/plain");response.setCharacterEncoding("UTF-8");request.requestProgressTracker.log("End Of Script Execution");request.requestProgressTracker.dump(response.writer);%>

We added three logging statements: Two statements with a fixed message and athird statement with a java.text.MessageFormat format string andits associated parameters. The output of this script when requesting the/missing.txt resource again is as follows (line numbers added by theauthor):

 1:      0 (2008-06-18 10:22:28) Starting Request Processing 2:      0 (2008-06-18 10:22:28) Starting ResourceResolution 3:      1 (2008-06-18 10:22:28) URI=/missing.txt resolves to Resource=NonExistingResource, path=/missing.txt, elapsed = 1ms 4:      1 (2008-06-18 10:22:28) Starting ServletResolution 5:      1 (2008-06-18 10:22:28) Starting resolverServlet(NonExistingResource, path=/missing.txt) 6:      4 (2008-06-18 10:22:28) Using Servlet /apps/sling/nonexisting/GET.esp, elapsed = 3ms 7:      4 (2008-06-18 10:22:28) URI=/missing.txt handled by Servlet=Script /apps/sling/nonexisting/GET.esp, elapsed = 3ms 8:      4 (2008-06-18 10:22:28) Starting /apps/sling/nonexisting/GET.esp#0 9:     13 (2008-06-18 10:22:28) Starting Script Execution10:     13 (2008-06-18 10:22:28) Script /apps/sling/nonexisting/GET.esp of type nt:file11:     13 (2008-06-18 10:22:28) End Of Script Execution12:     13 (2008-06-18 10:22:28) Dumping SlingRequestProgressTracker Entries, elapsed = 13ms

You will see the three log statements we added in the lines 9-11. Note especiallythe message on line 10, which formats the message by replacing the respectivecall parameters.

Logging Methods

• log(String message) -- Log this exact message
• log(String format, Object... args) -- Log a message whichis constructed from applying the arguments args to thejava.text.MessageFormat pattern format.

Timing Sections of the Script

Sometimes you might suspect timing issues in the scripts you have written andyou want to see where all these CPU cycles are being burnt. Here comes thetimer support the ResourceProgressTracker. The tracker allowsfor a virtually unlimited number of named timers. A timer is created or resetby calling the startTimer(String) method and the time ellapsed sincethe last timer start can be logged by calling any of the logTimermethods.

Let's see the timer functionality in action. Thus we adapt our GET.espto add a timer:

<%request.requestProgressTracker.startTimer("test");request.requestProgressTracker.log("Script {0} of type {1}",        sling.script.scriptResource.path,        sling.script.scriptResource.getResourceType());response.setContentType("text/plain");response.setCharacterEncoding("UTF-8");request.requestProgressTracker.logTimer("test");request.requestProgressTracker.dump(response.writer);%>

Here we define a timer named test and get the following output (linenumbers added by the author):

 1:      0 (2008-06-18 11:11:39) Starting Request Processing 2:      0 (2008-06-18 11:11:39) Starting ResourceResolution 3:      1 (2008-06-18 11:11:39) URI=/missing.txt resolves to Resource=NonExistingResource, path=/missing.txt, elapsed = 1ms 4:      1 (2008-06-18 11:11:39) Starting ServletResolution 5:      1 (2008-06-18 11:11:39) Starting resolverServlet(NonExistingResource, path=/missing.txt) 6:      5 (2008-06-18 11:11:39) Using Servlet /apps/sling/nonexisting/GET.esp, elapsed = 4ms 7:      6 (2008-06-18 11:11:39) URI=/missing.txt handled by Servlet=Script /apps/sling/nonexisting/GET.esp, elapsed = 5ms 8:      6 (2008-06-18 11:11:39) Starting /apps/sling/nonexisting/GET.esp#0 9:     12 (2008-06-18 11:11:39) Starting test10:     13 (2008-06-18 11:11:39) Script /apps/sling/nonexisting/GET.esp of type nt:file11:     13 (2008-06-18 11:11:39) test, elapsed = 1ms12:     13 (2008-06-18 11:11:39) Dumping SlingRequestProgressTracker Entries, elapsed = 13ms

In the dumped log you find the entry for the timer start in line 9 and the entryfor logging the elapsed time of the named timer in line 11. In our example weused the simple method of logging by just supplying the timer name to thelogTimer(String) method. You may log a more elaborate message withthe logTimer(String, String, Object...) method, which is alsoused by Sling to log timings for the resource and script resolution

Timer Methods

• startTimer(String timerName) -- Start a timer with thegiven name. If a timer with the same name already exists it is reset to zero.
• logTimer(String timerName) -- Logs the number ofmilliseconds elapsed since the named timer was last started. The name of thetimer is used as the log message.
• logTimer(String timerName, String format, Object... args)-- Logs the number of milliseconds elapsed since the named timer was laststarted with a message constructed by applying the args parametersto the MessageFormat pattern format.

Please note that only the startTimer method resets the timer tozero. The logTimer methods just log the number of millisecondselapsed. Therefore these latter methods may also be called multiple times tolog the increase of elapsed time.

Wrap-Up

In the previous sections you have seen how easy it is to use theRequestProgressTracker provided by Sling to track the processingof any requests. In this wrap-up I want to present three more bullet pointswith respect to the request progress tracker.

Helper Methods

• getMessages() -- Return all messages from the requestprogress tracker as an java.util.Iterator of Strings. This methodmay be used if you want to handle the logged messages other than just dumpingthem to some PrintWriter.
• done() -- This may be called to log a terminatingmessage. Currently this method has no other effect.

Automatic Logging of Messages

Sling includes a request filter, which dumps the request progress trackerto using a logger with name org.apache.sling.engine.impl.debug.RequestProgressTrackerLogFilterat debug level. To log the request progress tracker messages to a log filejust configure this logger for the debug log level.

The large international Java conference Jazoon is soon to start. Jazoon takes place end of June in Zurich, Switzerland. There will be six presentations given by speakers from Day. Hope to see you there:

Roy Fielding: Open Architecture

Keynote speech, Wednesday, 2008/06/25, 09:30-10:30, Arena 5

At the heart of most successful open source projects is an emphasis on open architecture -- at least one mechanism that allows the product to be utilized as a support network for unanticipated extensions and independently motivated functionality. Such extensibility mechanisms allow an open source project to decentralize its evolution and take advantage of Internet-scale collaboration. However, they can also be a source for unnecessary complexity and hidden barriers to entry.

Representational State Transfer (REST) is an architectural style that I developed to describe and redefine the World Wide Web. The essential constraints of REST are designed to promote the development of open architectures within Web-based applications, such that the resulting resources are reusable across independently developed systems (today, we call these "MashUps"). The same principles can be used to design other open architectures, though not necessarily with the same constraints. This talk will focus on applying principled design techniques to the design of open architectures, as demonstrated by various examples from successful open source projects.

Peeter Piegaze: The Next Content Repository: A sneak peek at the upcoming JCR 2.0

Technical long talk 50 min, Wednesday, 2008/06/25, 12:00 - 12:50, Arena 9

The Story So Far

• JCR 1.0 a quick recap
• JCR 1.0 successes
• JCR 1.0 lessons learned

• Expose new functionality for JCR-from-scratch repositories
• Better expose functions of existing legacy repositories through JCR
• Simplify complex features

• More flexible constraints

• Standardizing metadata node types

• Two semantic levels of event reporting: state-change and method
• Journaling

• Simple and full versioning options

• enabling multi-filing without breaking the workspace tree semantics

• Abstract Query Model allows multiple equivalent syntaxes
• Java bindings and SQL bindings
• XPath bindings and more

• Creating and registering node types

• Access control discovery
• Access control policies
• Access control entries

Lars Trieloff: Creating RESTful Web Applications with AJAX and Web Forms 2.0

Technical long talk 50 min, Wednesday, 2008/06/25, 16:30 - 17:20, Arena 5

The talk will have following structure: Introduce the concepts REST, AJAX and Web Forms 2.0 first, then provide hands-on-examples on building applications using these concepts. REST is a principle of creating large-scale internet applications and is seen by many developers as the way to go for creating web applications. The problem with real-world REST application however is that current web browsers only implement a subset of the HTTP specification that makes it hard to create true RESTful applications that work in a web browser. AJAX is a way of creating highly dynamic web applications that use Javascript and client-side DOM manipulations for interaction with the user and background HTTP request in XML or JSON for real-time-interaction with the browser. Combining AJAX and REST allows the creation of rich internet applications running in the browser that follow the REST principles. Web Forms 2.0 is an emerging web standard that tries to overcome some limitations with classical forms in HTML pages that are today the standard way of user interaction in web applications. Web Forms 2.0 add concepts like form field repetition, different transport encodings and validation. As long as only a small fraction of web browsers support Web Forms 2.0, implementing Web Forms 2.0 with AJAX is an elegant solution for creating standards-based web applications. In the practical part of the presentation concrete coding examples of creating RESTful web applications using Web Forms 2.0 will be given. The frameworks involved in this example session will be Apache Sling, a web-framework that combines concepts of REST, server-side scripting, OSGi and JCR and the Dojo Toolkit, a powerful collection of Javascript APIs that allow the creation of widget-based applications that run in a web browser. Apache Sling is an incubating project of the Apache Software Foundation.

David Nüscheler: Content Integration: Java(tm) Applications vs. Microsoft(R) Sharepoint

Technical long talk 50 min, Wednesday, 2008/06/25, 17:30 - 18:20, Arena 9

Most large organizations on the one hand develop Java(tm) Applications and on the other hand run Microsoft(R) Sharepoint for their business users.

This generates the crucial need for Java Applications to be able to interact with content stored in Sharepoint, be it a Java based Swing Application that would like to refer to content managed by Sharepoint or a regular Intranet WebApp or Java Portlet that needs to search and manage office content residing in Sharepoint.

This session will talk about the benefits and drawbacks of various ways of integrating Java applications and Sharepoint.

This session will also demo and showcase the integration of both J2SE and J2EE applications through a quick and easy to use standards based integration.

The goal of this session is to demonstrate in a practical fashion how to integrate with Microsoft Sharepoint at a Content Repository level using a "Content Repository API for Java(tm) Technology" (aka JSR-170) connector to build a Java application in a very agile fashion.

Expect a hands-on demo of the installation and deployment of a JSR-170 based Sharepoint Connector and the development of a simple JSR-170 based application and the use of an existing JSR-170 based application backed by content from Microsoft Sharepoint.

Agenda:
(1) Content Integration: A Business Issue
(2) Java vs. Microsoft Sharepoint
(3) Various Integration Options Pro/Cons
(4) Integration Demo using the "Content Repository API for Java(tm) Technology"
(5) Q&A

David Nüscheler and Bertrand Delacrétaz: The Revenge of the "Weblog in 15 minutes"

Technical long talk 50 min, Thursday, 2008/06/26, 12:00 - 12:50, Arena 5

Based on last years successful Jazoon session on how to build a "Weblog in 15 minutes" using AJAX and JCR, this talk is the sequel in the "AJAX meets JCR" series.

In the meantime microjax has become a legitimate part of the Apache Sling project which is at the time of this submission in incubation.

This talk will focus on the unique benefits of using a combination of AJAX and JCR (aka. JSR-170 & JSR-283) to satisfy modern Web 2.0 application requirements and allow for an extremely agile application development.

To take last years "15-minute weblog" example to the next level we will talk about how microjax effortlessly complies with the real-life requirements of Search Engine Optimization (SEO), Back-button, Deep Links, WAI, Access Control, XSS protection, etc...

This session will be interesting for an audience that works in a general J2EE environment and is eager to learn how to build Web2.0 Applications in a very efficient way without leaving the traditional heavy-weight j2ee style backend resources.

The session overview looks as follows:

(1) The JCR elevator pitch
(2) microsling - JCR and AJAX
(3) The revenge of the microjax "weblog"
(4) The real-life: SEO, WAI, Backbutton, XSS, Access Control
(5) Q&A

Thomas Mueller: Java SQL Databases

Technical short talk 20 min, Thursday, 2008/06/26, 11:00 - 11:20, Arena 3

This talk is about what persistence mechanism to chose for your Java application, and what to consider when you decided to use a SQL database as your backend. The focus of this presentation is open source Java databases. One of those, the H2 Database Engine, is developed by the speaker.

The API is one aspect of the persistence mechanism. Standardized high level APIs are the JPA (Java Persistence API), the JDBC API (Java Database Connectivity), and the JCR (Java Content Repository) API. Each API has advantages and disadvantages. Other APIs exist as well, but are less used (such as JDO) or are proprietary. Proprietary APIs will result in substantial cost when switching to another product to overcome the vendor lock-in (for example when using db4o).

If you have decided to use a SQL database as the backend, you need to think about which products fit your use case best. The main factors factors to consider are: cost, stability, security, features, performance, ease-of-use, support, and documentation. Sometimes, you will want to support multiple products: one for development and unit testing, and another (or multiple) for production.

If you already purchased a SQL database, for example Oracle or MS SQL Server, you may want to use it for production. If not, the cost of such products can be avoided by using free databases like PostgreSQL, or MySQL (which is not free in all cases). There is also a number of Java databases, most of them are free.

Some think that Java still is slow, and a fast database can not be written in Java. However Java is no longer slow. Additionally, there is no network overhead when accessing Java databases from Java applications in embedded mode. Therefore, Java databases are much faster than other database in many situations.

The main open source Java databases today are HSQLDB, Apache Derby, and H2. There are other Java databases, but some are not free (PointBase), and others not updated since a long time (McKoi, DaffodilDb/One$Db, Quadcap). HSQLDB, Derby and H2 are quite different. According to Ohloh, HSQLDB is the most popular one, followed by Derby and H2. The reason is probably that HSQLDB is the open source since a long time, Derby since 2004, and H2 since the end of 2005.

HSQLDB is based on Hypersonic SQL, which was developed by the author of H2. It is now maintained by a group of people headed by Fred Toussi in England. A commercial version of HSQLDB is available as well. HSQLDB is popular because of its speed. However it does lack a few features such as locking and transaction isolation. HSQLDB is bundled with OpenOffice Base. Many use HSQLDB for testing. However, more complex queries can be very slow in HSQLDB because the query optimizer does not consider different access strategies. There is no ODBC driver for HSQLDB.

The history of Apache Derby goes back to 1996. Cloudscape was bought by Informix in 1999, which was bought by IBM in 2001, and then contributed to Apache in 2004. IBM stopped selling Cloudscape in 2007 and will stop support in September 2008. However most Derby developers are employed by IBM. Sun offers commercial support for Java Db, which is basically Derby. Since 2007 IBM owns PointBase, the second commercial Java database. Derby offers a rich feature set. The optimizer usually chooses a good query plan. The main disadvantage is the slow performance for simple use cases (up to 10 times slower than HSQLDB or H2).

The development of H2 was started in 2004, but it was first published in December 2005. The author of H2, Thomas Mueller, is also the original developer of Hypersonic SQL. In 2001, he joined PointBase Inc. where he wrote PointBase Micro. At that point, he had to discontinue Hypersonic SQL, but then the HSQLDB Group was formed to continued to work on the Hypersonic SQL codebase. The name H2 stands for Hypersonic 2; however H2 is built from scratch. H2 is feature rich and fast. The main disadvantages are: it is relatively new, and there is no commercial support as of today.

Day's European Tech Summit 08 took place in Basel a couple of days ago. If you could not make it there find some of the presentations below.

Gilles Metz: Support Initiative 08

| View | Upload your own

Lars Trieloff: Getting into the Flow with CQ DAM

| View | Upload your own

Lars Trieloff: Advanced Collaboration and Beyond

| View | Upload your own

David Nüscheler: Non CMS Web Apps

| View | Upload your own

Honwai Wong: TAR PM & Clustering

| View | Upload your own

Jean-Michel Pittet: CQ WCM and Connectors

| View | Upload your own

Honwai Wong: Top 2 Support - Dispatcher & Out of Memory

| View | Upload your own

Christian Sprecher who wrote about JCR and Groovy on dev.day.com in January has released some code for Groovy/JCR Object-Content-Mapping on Google code. It is used like this:

def myBeer = Beer.get("Ueli Bier")
myBeer.taste = "excellent"
myBeer.save()

This would persist the myBeer POGO (plain old Groovy object) in the underlying Java Content Repository. Cool (and it presumably works with other types of beer as well).

The objects that shall be persisted must have a key so that they can be retrieved again. If an object has a reference to another one it will be persisted as well:

class A {
        B myB
        def key
}

class B {
        def alsoKey
}

B b = new B(alsoKey:"I am b's key")

A a = new A(key: "I am a's key", myB: b)

a.save()
// not needed: b.save() 

The project is pre-alpha, but it is certainly promising.

Speaking of Groovy: a project has been started to optionally swap out the RDBMS backend Grails is using and plug in a JCR backend (some code is here: https://svn.codehaus.org/grails-plugins/grails-jcr/). I am looking forward to see more from that!

PS: I cannot resist the urge to point to the nice Freudian slip in the project's tag line (spotted by Dierk Koenig).

Both, TheServerSide and InfoQ, have just come out with interesting publications regarding Java Content Repositories:

InfoQ founders Alexandru Popescu and Floyd Marinescu explain InfoQ's architecture and the backend. InfoQ is built upon a custom-made CMS backed by Apache Jackrabbit. Floyd and Alexandru also provide a nice overview over their views on JCR, why they chose to use it and what their content model looks like.

On TheServerSide David Dossot the author of Mule's JCR transport is discussing "Building Content Oriented Integration Solutions With Mule and JCR". We interviewed David about his views on JCR on dev.day.com.

Update (10/06/2008):
InfoQ has just published an additional item on JCR, Sling and REST: Stefan Tilkov interviews Day's CTO David Nuescheler.

Two weeks ago I blogged about integration of Spring and Sling into Spling (btw: if you speak German check out Sandro Ruch's post on the topic). Regarding access to the repository content from a Spring-based application I wrote back then:

So integrating the content really just involves sending HTTP requests. This approach will carry you very far without having to resort to JCR connections (but it surely feels comforting that this lower level access is always there).

Of course, in the workshop described in the post we were considering only Communique 5 which is built on top of Sling. However, in Communique 4 there is no Sling so it is more likely that you end up in a situation were you want to access the repository through JCR.

It turns out that this is exactly what Shane Johnson from CityTech set out to do: Shane has written a very nice post about using Spring's JcrTemplate to access CQ4's repository.

Day engineer Bertrand Delacretaz has been elected into Apache Software Foundation's Board of Directors. The board is responsible for

management of the corporate assets (funds, intellectual property, trademarks, and support equipment) and allocation of corporate resources to projects.

Congratulations to Bertrand.

Last Friday I had a presentation at 11th ICTAC Meeting, hosted by the European University Institute in Florence. ICTAC is a periodic meeting of ICT (Information Communication Technology) managers from European Union Agencies. My presentation was titled "Standards-Based Solutions for EDRMS".

Slides are not available as it was not a public meeting, sorry. I presented Day's products, technologies, and standards on which they are based. This product stack can be used to build a document/records management system based on a central content repository, integrated with other available systems, and extended using the open architecture of Day products. The key building blocks for this kind of system are RESTful content applications and the feature-rich JCR content repository.