cocoon-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Arje Cahn" <>
Subject [GT2006] 17 talks proposed!
Date Wed, 13 Sep 2006 10:32:43 GMT

       *                             *
       *   Cocoon GetTogether 2006   *
       *                             *
       *     October 2nd to 4th      *
       *                             *
       * Amsterdam, The Netherlands  *
       *                             *
       * Current count: 61 attendees *
       *                 9 countries *
       *                             *
       ****** *******

Hi there,

17 proposals! Pretty good (much more than last year), although Andrew is 
drastically obfuscating the statistics by proposing no less than 6 talks

In total, we can host about 8 45-minute sessions, so we need to decide on 
which 8 or 9 talks have to go.

I'd like to do the voting procedure slightly different this year, in the 
sense that everyone who has signed up to the event will receive an invitation
to cast his or her vote. If you feel like voting, but have not yet 
registered, *now* is your change! :-) 

(I'm getting more and more of a conference salesperson these days :) )

Voting will be off-list and monitored by myself and Steven Noels.

Before starting the whole voting procedure, I'll await any discussion on 
the talk proposals. So, let me know what you think of the talks!

Here they come:


1) Arje Cahn: "101 Cocoon Marketing Graphs"

   A short presentation on the outcome of this year's registration survey.
   101 graphs to show to your manager.
   Time: 20 minutes

2) Andrew Savory: "Things your mother never told you about Cocoon 
                   (The secret gems of Cocoon rebranded)"
   This session will uncover some of the deep, dark secrets of Cocoon that 
   most people never discover. This will draw on the "ah-ha!" moments from 
   various Cocoon training sessions, and from a quick Google search for 
   "Cocoon Eureka!".

3) Andrew Savory: "10 Reasons to use Cocoon"

   In this session, you'll hear 10 irrefutable reasons to start using Cocoon 
   or switch your application to Cocoon right away.
4) Andrew Savory: "Cocoon reloaded: moving from xsp and actions to newer 

   This session will use a couple of ancient cocoon 2.0 web sites to 
   illustrate how to make the most of the new Cocoon features such as flow 
   and jxtemplate.

5) Andrew Savory: "Case studies"

   What do the BBC, Warwick University and two Visual Arts galleries have 
   in common? Find out how Cocoon helped each of these organisations to not 
   just build basic web sites, but also to provide dynamic 
   user-generated-content-driven immersive web experiences. (*cough*)

6) Andrew Savory: "An illustrated guide to Cocoon technologies"

   (How to NOT get lost in Cocoon technologies rebranded)
   Actions, Authentication, Databases, Flow, Forms, Generators, i18n, 
   Matchers, Persistence, Portals, Serializers, Sitemaps, Transformers, 
   XSP: you could be forgiven for thinking Cocoon developers speak a 
   different language. This session will be a lightning illustrated guide 
   to what makes Cocoon applications tick.

7) Andrew Savory: "Cocoon archetypes (How to create a "typical" project 
                   with cocoon rebranded)"

   Over the past six years of building Cocoon apps, we've seen it all - 
   ant, cvs, hacking by hand, maven, shell scripts, subversion, 
   telekinesis: find out here how to follow Cocoon best practice (or avoid 
   Cocoon worst practice) when putting together a typical Cocoon project 
   from scratch.

8) Reinhard Potz: "PMC Chair opening keynote"
   Time: 20 minutes?
   (Reinhard has not yet responded on my question if he'd want to say 
   something, but I guess it would be good to have him or someone else
   present the 'Cocoon state of the project')
9) Andreas Kühne: "'Cocoon at work' or 'things running unexpectedly smooth'"

   Giving an overview of a succesful midsize project using cocoon for 
   the upper layer. It's about a signing / verification server running as 
   well in an intranet ( signing administration ) as well on the internet 
   (free verification service).

   The base layer is implemented using EJBs on jBoss. This backend is 
   adapted by a special 'Invocation transformer'. It serves well in 
   separating bean access out of other parts of the cocoon layer. Short 
   example of a EJB invocation is given.
   Cocoon shows it's well-known strength
   - authentication / session framework
   - i18n
   - multi-channel output of backend data ( e.g. PDF )
   - multi-client-support ( SoC example )
   - easy to expand ( e.g. transformer for signed / encrypted mails )
   - ajax support out of the box

   Most important
   - runs for years without problems
   - easy to expand for new clients
   - fast turnaround cycle ( xslt, sitemap, xsp ... instantly ) compared to 
      EJB layer
   - reliable ( didn't came across a cocoon bug, yet )

   real life experience
   - several thousand customers
   - serving legal requirements ( no 'one visit and forget' page )
   - no customer complains ( except for Java applet security probs )

10) Bertrand Delacretaz: "Subversion and Solr - your next content repository?"

   Many content management systems seem to reinvent the wheel when it comes 
   to content storage: versioning, triggers, generating differences, all these 
   functions have been available in source code control systems for a long 
   time. When combined with a full-text and structured index, Subversion 
   provides all the required functionality, without using exotic tools and 
   with little custom code.

   In this talk, we'll present a prototype content repository based on 
   Subversion and the Lucene-based Solr indexer (pronounced "solar"), using 
   Cocoon to prepare content for indexing and as a front-end for searching.

   We will show how the basic CRUD+ functions are implemented, using very 
   little code, taking advantage of these powerful tools.
11) Arjé Cahn: "Massive websites by example (featuring Hippo CMS and Cocoon)"

   This talk introduces Hippo CMS as an open source Cocoon-based content 
   management system for managing large sets of XML documents. Recent websites 
   build by Hippo and Sourcesense will be used to demonstrate the features 
   of Hippo CMS and the scalability of Apache Cocoon. 
   This talk is more than just another CMS presentation: it demonstrates why 
   Cocoon is such an excellent platform for delivering large-scale websites 
   and intranet applications.

   Level: beginner
   Time: 30 minutes

12) Nico Verwer: "Domain Specific Languages and Cocoon"

   Many applications depend on the knowledge of domain experts to perform 
   their functions. The representation of domain-specific knowledge in an 
   application can be done by software engineers writing code, but this is 
   inefficient, potentially inaccurate, and leads to high maintenance costs.
   Domain-specific languages (DSL) are an example of the Separation of 
   Concerns principle. They allow domain experts to directly enter their 
   knowledge into a system,  whereas software engineers design and implement 
   the DSL. This approach is not new, but has recently attracted attention 
   because it is supported in Visual Studio 2005 and Ruby. Of course, 
   Cocoon has supported the implementation of DSLs for many years, although 
   few people may have been aware of this. In this talk we will present 
   some design patterns for implementing DSLs in Cocoon. We will show some 
   examples from book and journal publishing, such as large-scale document 
   conversions, content-assembly and customized lay-out.

13) Gustavo Nalle Fernandes: "Devware - bringing Cocoon-related technologies 
                              to the development environment"
   In this talk the speaker presents devware [1], a free vmware-based server
   composed of several integrated open sources tools already installed
   and configured that are used by development groups in small or 
   large projects to manage the life cycle of a product.
   In devware Apache Daisy play a central role, providing an entry point 
   to all other tools such as scarab, subversion, luntbuild, maven and 
   mainly projects documentation. Session outline:

   - What is devware and what it is used for
   - Devware tools and servers
   - Brief description of daisy capabilities
   - Demo
   - Extending daisy with cocoon pipelines to use dynamic content in documents
   Session prerequisites: Basic knowledge of cocoon 
   Session extras: the audience will receive a DVD containing devware
   Session duration: approximately 30 minutes

14) Daniel Fagerstrom: "Reusable webapps with Cocoon blocks"

   It will be shown how to build reusable webapps using the (forthcomming) 
   blocks framework in Cocoon 2.2. The blocks framework make it possible to 
   create configurable webapp "blocks" that in turn can be extended and 
   overrided by other blocks. There are mechanisms for communication between 
   blocks. The blocks mechanism also makes it easy to build webapps that 
   combine Cocoon blocks with other servlets.

   The talk will be about 45 min and is intended for a medium to advanced 
   audience. The stuff that I will talk about works in the OSGi mode but not 
   yet in Cocoon 2.2, I'm currently working on "backporting" it to 2.2.
   The talk will be more or less applied depending on how far we get in this 

15) Bruno Dumon: "Document publishing in the Daisy CMS"

   The frontend of the Daisy CMS, called the "Daisy Wiki", which is based on 
   Cocoon, has a powerful infrastructure for publishing documents. It offers 
   advanced features (recursive processing of inclusions, document type 
   specific styling, link and image annotation, and much more) at an 
   attractive speed (when not caching the published content). After an 
   introduction of what is functionally offered, this talk will delve into 
   explaining the conceptual and implementation details of how all this 
   achieved. Limitations and disadvantages of the current approach will also 
   be addressed.

   So how is this interesting to Cocoon people? The publishing engine is 
   largely Cocoon-based, using various pipeline executions with various 
   transformation stages. Sharing the design considerations that went into 
   it should be interesting for many. The Daisy CMS is also used by the 
   Cocoon project to manage its documentation, making a deeper understanding 
   of it interesting for Cocoon contributors.

16) Ross McDonald and Jeremy Quinn: "Real life, down-to-earth Cocoon and LDAP"

   beginner level
   - why and when to use LDAP?
   - a contrived example
   - why might this be perceived as difficult?
   - the setup and use of LDAP
   - the setup and use of Cocoons LDAPEntryManager
   - how to use the LDAP component from your own code

   intermediate level
   - empowering developers/designers to build LDAP applications
   - some tips and tricks for large scale LDAP instances

17) Ard Schrijvers, Niels van Kampenhout and Bart van der Schans: 
    "Making Cocoon web sites perform"

   This talk demonstrates all you need to know to make your Cocoon website 
   perform. Starting from the browser, the server OS, JVM, the 
   webserver, to Cocoon caching and all the way up to load balancing.
   Also, there are some guidelines presented to demonstrate how to correctly
   measure the performance of your website so you can develop for *speed*!
   - Return the right headers: expires, pragma, etc
   - Using Apache mod_cache
   - Tuning for browser caching, proxy caching, server caching, etc
   - Using the Cocoon cache: caching, noncaching, ecaching
   - JVM performance and OS specific notes
   - Cocoon cache keys and stores
   - Load balancing Apache Cocoon
   - Measuring performance using Solex and TCPMon

   Level: intermediate

Kind regards,

Arjé Cahn


Oosteinde 11
1017WT Amsterdam
The Netherlands
Tel  +31 (0)20 5224466
------------------------------------------------------------- / /

View raw message