Carsten Ziegeler: Cocoon

Finally, we reached the next release of Cocoon, Version 2.0.3. Now, we can focus again on the next step: version 2.1. Thanks to all who helped, especially the QA testers!

It seems that 2.1 will be a very big step for Cocoon. We have all the new stuff, the tree processor, the authentication framework, the portal engine, form handling, flow maps etc.

And we have the new documentation effort and it seems that we will also address the need for a minimal Cocoon, making upgrading easier.

And if we will also have the blocks in 2.1, well what else do you need - uhm, perhaps a good book about Cocoon?

Just have a look at the Cocoon developer list and you will notice some of the good new things...

Last (?) changes to the validity testing: the isValid() method of a SourceValidity can now return three values (-1, 0, 1). This makes testing a little bit faster than the old boolean solution.

Hmm, I changed the key generation code for the caching from String to Serializable, removed all the String operations and reinstalled (a better?) compound key handling for the caching algorithm.

Now everything is in place, only bug finding remains...

I just finished the initial implementation of the new processing pipeline. The only thing missing is to use it :)

Have a look here for a preview version of sunBow, an IDE for Cocoon!

I still need time to finally finish the new caching algorithm.... :(

I did a quick performance test and it seems that using strings for cache keys is not slower than using hash values. Why? Because the information or key is already a string and hashing creates an overhead.

If you are looking for an IDE for Apache Cocoon, have a look at Martin's weblog.

I just started a random though on how to generate the cache key for the Cocoon caching algorithm.

While writing the new caching code, I spotted that the old one is really very imperformant and not so clever as it could be :(

The new caching algorithm will use less hashtables and maps and less object creations. In addition, if only a part of a response is cached, but more can be cached during this processing, the cached part is used to drive the new response (and this is then cached). Sounds a little bit complicated, so here is an example:

Requested: G(c) -> T1(c) -> T2(c) -> T3(c) -> S(c)

The pipeline above is completly cacheable (indicated by the c), but the cache contains only this:

Cached: G(c) -> T1(c)

Now, the old caching algorithm does not use the cached result, so the complete pipeline is processed. The new caching algorithm will use the cached response, feed it into T2 and then cache the complete pipeline.

Ok, perhaps there are only rare cases where this is needed, but I think it's cool anyway.

I just started the new Cocoon Cache Component. This component can be used to monitor the state of the Cocoon caching system: how many responses are cached, which responses etc. It can also be used to clean the cache or implement anything you want. Of course, this is an Avalon Component, so it's simple to change/add behaviour.

The interest in the portal and authentication framework (aka sunRise and sunSpot) is growing day by day! That's great. Matthew and I will give a session about those two components at the JAX 2002 next week And Guido will give a session about integrating XML databases into Cocoon. So if you have time, just come around.

Perhaps I can add a new story about authentication to my weblog soon...

I just started with the new internal architecture of Cocoon: the XML processing pipeline. This will be the combination of the event and the stream pipeline. And it will also be configurable. The first design phase is finished, now the implementation will follow next week (hopefully).

Just a thought: how is it possible to combine Apache Cocoon and Apple WebObjects? These are - in my eyes - to two most innovative products around, especially the EOF is simply great. What I would like to do is to define a WO component as a Cocoon pipeline. This would then use WO to generate XML, filter the WO tags and this XML is then send through a Cocoon pipeline with all these nice transformers etc. and from there somehow into the response. Hmm, very rough idea - perhaps someone else has a better one?

This is my new category for Apache Cocoon.

This is a test.