Sessions

Cocoon: what do you need to know?

To beginners, Cocoon's rich toolset is sometimes perceived as a scary jungle of functionality.

Where to start? What to learn? Will I make it? Will it be worth it?

Focusing on the essential components and concepts of Cocoon, this talk helps you answer those questions, and provides a roadmap to shorten the trip and make it as enjoyable as possible.

We start with an overview of an actual web application built on Cocoon, and show how understanding a handful of essential concepts and components (Pipelines, Flow, Forms, basic Avalon concepts) is sufficient to start building powerful applications.

There's a catch, however: as with any complex framework, this is only true if the developer or team have the right skillset and mindset.

To help people evaluate their (or their team's) potential with Cocoon, we describe the skills needed to work with it at various levels (multi-channel publishing, database access, java business logic programming, debugging, etc.), and describe the kind of "know a little about many things" mindset that helps so much in getting started or going forward with Cocoon.

Test-driven development with Cocoon

Test-driven development is one of the core practices of Extreme Programming. It allows application development teams to focus on what needs to be done, to work in short cycles, to respond rapidly to changes, and to continuously measure how well their code is doing.

Testing frameworks such as Junit have been developed for many programming languages, including XSLT (xsltunit.org). XSLTUnit allows stylesheet developers to set up unit tests for individual stylesheets, but it does not include a framework.

In order for test-driven development to be practical, test suites must be defined and successfully run, every time when changes are committed to the code base. For Cocoon application development, transformers other than XSLT, and complete pipelines must be tested. In this talk, a framework for test-driven development in Cocoon is proposed.

With this framework, developers can define unit tests, test suites, and generate test reports. The framework is easy to use, and minimizes the effort of writing and running tests, encouraging developers to write as many tests as possible. The framework has been developed and used for about a year in several projects using Cocoon, and has lead to a notable increase in software quality.

The testing framework (which has no name yet) is now undergoing its last revision before it will be released as Open Source Software. This talk will present its design, and show how it is used in practice.

Advanced Cocoon Forms: dynamic templates and recursive forms

Cocoon Forms offers some unique features to build advanced forms, easily overpassing other form frameworks. This session will present some of these advanced features and how you can use them in your projects:

• dynamic templates to produce a page layout that depends on the form contents,
• the <fd:union> for variants,
• the <fd:class> and <fd:new> widgets for recursive forms.

This session will present some real-life use case and how they were implemented.

Impress your boss: Cocoon success stories

A one-of-a-kind session: the stage will be shared by speakers from all around the world coming to Gent to show and tell their latest achievements with Cocoon. People attending will get back home with enough material to convince even the most skeptical boss that Cocoon is the way to go!

Developing Enterprise Web Applications with Cocoon and Spring

The Spring Framework is a "lightweight" container based on the principles of Inversion of Control and Dependency Injection that aims to reduce the complexity of developing enterprise Java applications.

The presentation will focus on how Cocoon and Spring can be used together to provide a powerful web application development. It will demonstrate the usage of best practices (separation of concerns, layering, testability, etc.) and of patterns of enterprise application architecture (Application Controller, Domain Model, Lazy Load, Serialized LOB, Service Layer, Two Step View, Optimistic Locking, etc.) in the context of real-world applications.

Using a hands-on approach, it will introduce the following techniques:

• Finding and invoking Spring-managed services from Cocoon.
• Using Aspect Oriented Programming to provide transparency and declarative transaction management.
• Using Object-Relational mappers to bridge the O-R gap.

In the end, we aim to demonstrate how the development of Java enterprise web applications can be made simpler and more effective with the right combination of patterns and Open Source tools.

Open Source CMS shootout

Two new Open Source CMS projects, based on or related to Cocoon, get in the boxing ring and give an elevator-pitched showdown of their unique propositions. Expect friendly fighting and a no-nonsense approach towards solving real-world CMS problems.

Cocoon Projects: Best Practices

In this session Jeremy will present some suggestions for how to develop a Cocoon-based application, based on past experiences and tips collated from various colleagues. The session will cover best practice for setting up and configuring Cocoon, building applications within it, testing and deploying the applications, and working within an Open Source context. The contents of the session will also be made available in the Cocoon wiki, where hopefully it will be collaboratively improved during the session and in the future.

Supporting non-Latin character sets with Cocoon

Working with non-Latin character sets (such as Russian, Arabian / Persian, Japanese, Korean or Chinese) isn't as easy as just using UTF-8 all over the place. This presentation will dissipate every doubt when it comes to using non-Latin alphabets for web sites and publications.