ApacheCon US 2005

T01: How to Unit Test the User Interface of Web Applications

Thomas Dudziak

Web applications are of ever increasing complexity both on the server and the client side. The latter is especially true with the incorporation of new technologies such as AJAX which move certain parts of the flow logic to the client. However testing web applications is usually limited to the server side and to testing with libraries that mimic a client, but not using a real browser. In this session we will show how the user interface of a Java based web application can be tested in a real web browser (Mozilla) in normal JUnit tests. For this purpose, we will examine a sample webapp that uses common web application technologies (spring, spring-webflow, struts, OJB) and also incorporates some AJAX functionality. For this web application, we will showhow to programatically setup the database for each of these tests using the DdlUtils project, how to capture the behaviour of the user interface in simple unit tests that use a real browser and how these tests are performed using normal web servers/servlet containers (Jetty, Tomcat).

T02: Apache Derby: Hands On Tutorial

Jean Anderson

The first 25 people to register for this tutorial will receive a 50% scholarship courtesy of IBM, making the cost of this tutorial $175 for the first 25 registrants.

This hands on tutorial teaches the basics of Apache Derby, a Java embedded relational database. It will begin by providing an overview of Derby and show how to use the ij SQL command line tool and the Derby Plugin for Eclipse. Next, it will focus on embedded database capabilities and show how to deploy a simple JDBC application in embedded mode. Last, it will focus on the Derby Network Server and show how to use the Derby Network Client to deploy applications using the familiar client server model. Students are expected to have an introductory, working knowledge of SQL and JDBC. Bring the device of your choice that can run a certified J2SE JDK of 1.3 or higher. The instructor will provide CDs with the Derby software. Although this tutorial is free, preregistration is required to ensure minimum enrollments are reached.

T03: Smart Presentations with Apache Forrest

Ferdinand Soethe

Single Source Publishing can be a lot more than just publishing print and Web from a single source document. This session is about using Apache Forrest to create and present 'Smart Presentations'. Automatically generate presentation slideshow, handouts and other supporting documents from the same XML-document. Hand out good looking, functional documents designed for printing instead of printouts of your slides. Use any browser to present your slides without need for proprietary runtime modules or loss of functionality. Include todos, open questions and points for further consideration right along with your content. Show them as separate lists or within a workinging draft of your presentation script. Add permanent didactical comments to help other speakers understand and adapt your presentation. Add hints for the speaker ('talk about ...') that show on the Laptop screen while being invisible on the beamer overhead. Simplify shared presentations with color-coded versions of the script for every speaker which clearly show hand-overs and timing. Avoid duplication of slides by recombining slides from the same repository in many different presentations. Make use of the power of XML-grammars (relax-ng) to help authors avoid common design mistakes (too many bullet points on a slide).

T04: Scalable Internet Architectures

Theo Schlossnagle

We will discuss both good and bad design methodologies for building new sites, scaling growing sites up and scaling shrinking sites down. Primarily example-based, the presentation will show the progression from anecdotal conclusions to real-world practical results and often how the two are askew. We will discuss in detail three distinct and related problems in clustered web architectures: 1. high availability and load balancing 2. caching static and dynamic content 3. distributed logging and troubleshooting

T05: Portlet Development using JSR-168

Noel Bergman

Portals provide standardized delivery of personalized and aggregated content. Portlets are the key to developing portals, and JSR-168 provides the first standard Portlet API for Java developers. This specification gives developers the same ability to build a common marketplace that the Servlet Specification provided for server-side web components. Presentation will include coverage of the standard API, examples of Portals to inspire attendees, use of Pluto/JetSpeed2, and some vendor extensions as permitted by JSR-168. Note: This tutorial will be an interactive tutorial. Attendees should bring a laptop with either USB or CD-ROM support, preferably with a current version of Apache Jetspeed-2 pre-installed, and be prepared to develop Portlet code throughout the course of the workshop.

T06: Building Adaptable Meta-Components for Struts, Tapestry, MyFaces, etc.

Jonathan Lehr

Meta-components can greatly enhance the testability and maintainability of a web application, but many of today's Java web application frameworks don't support components well. And those that do, such as Jakarta Tapestry and the upcoming Struts 2.0 Shale, take very different approaches. Developers may be understandably hesitant to develop meta-components if that will lock them in to a single framework We'll explore an approach that allows meta-components to be designed for portability across frameworks, allowing for a common design that can be adapted to multiple frameworks, even those lacking built-in support for components (e.g. Struts 1.x). As an example, we'll look at a meta-component that presents lists of objects in paginated, sortable, filterable tables that can be rendered in both HTML and RTF, and that works with both Struts and the Apache MyFaces framework.

T07: Introduction to the Apache Web Server

Rich Bowen

Geared to to Apache Web server administrator who is just getting started, or the admin that has been doing this for a while but needs to step back and get a comprehensive overview of everything there is to know. This tutorial starts at acquiring and installing Apache, and goes through configuration, security, dynamic content, authentication, and performance. Covers Apache 1.3 and 2.0.

T08: Embedding Apache Directory Server into Applications

Alex Karasulu

The Apache Directory Server (ApacheDS) is embeddable within applications and application servers to provide directory and security services out of the box. This session with describe and step through the process required to embed ApacheDS within an application. The configuration of the server for embedded operation as well as the API’s will be discussed. If time permits an embedded application will be built and demonstrated during this session.

T03: Smart Presentations with Apache Forrest

Ferdinand Soethe

Single Source Publishing can be a lot more than just publishing print and Web from a single source document. This session is about using Apache Forrest to create and present 'Smart Presentations'. Automatically generate presentation slideshow, handouts and other supporting documents from the same XML-document. Hand out good looking, functional documents designed for printing instead of printouts of your slides. Use any browser to present your slides without need for proprietary runtime modules or loss of functionality. Include todos, open questions and points for further consideration right along with your content. Show them as separate lists or within a workinging draft of your presentation script. Add permanent didactical comments to help other speakers understand and adapt your presentation. Add hints for the speaker ('talk about ...') that show on the Laptop screen while being invisible on the beamer overhead. Simplify shared presentations with color-coded versions of the script for every speaker which clearly show hand-overs and timing. Avoid duplication of slides by recombining slides from the same repository in many different presentations. Make use of the power of XML-grammars (relax-ng) to help authors avoid common design mistakes (too many bullet points on a slide).

T10: Tapestry 4.0: Ready to Rock

Howard Lewis Ship

The buzz around Tapestry has been growing over the last year, even in the face of competition from Sun's JavaServer Faces. This session will provide a detailed introduction to Tapestry. We'll see the advantages of Tapestry's tool-agnostic approach, the ease with which existing components can be combined to form Tapestry pages, and even see how easy it is to create entirely new components. We'll also demonstrate the new features in Tapestry 4.0 that streamline development even further. Along the way, we'll explore the factors inherent in Tapestry that allow it to scale to large teams and complex applications. Tapestry makes web application's productive to developer and fun to boot ... come see why!

T05: Portlet Development using JSR-168

Noel Bergman

Portals provide standardized delivery of personalized and aggregated content. Portlets are the key to developing portals, and JSR-168 provides the first standard Portlet API for Java developers. This specification gives developers the same ability to build a common marketplace that the Servlet Specification provided for server-side web components. Presentation will include coverage of the standard API, examples of Portals to inspire attendees, use of Pluto/JetSpeed2, and some vendor extensions as permitted by JSR-168. Note: This tutorial will be an interactive tutorial. Attendees should bring a laptop with either USB or CD-ROM support, preferably with a current version of Apache Jetspeed-2 pre-installed, and be prepared to develop Portlet code throughout the course of the workshop.

T12: Struts on Steroids: Leveraging Bolt-On Components

Jonathan Lehr

Learn how to design, build, and use powerful, coarse-grained components using the Struts framework in this intensive, hands-on tutorial. We'll integrate an available ListView component into an example application and then learn how to build a TreeView component from scratch. The ListView component will provide fully implemented pagination, sorting, filtering, selection management, styling, and drill-down for arbitrary columns defined in an XML config file. The TreeView will allow recursive nesting, and will support a config setting allowing it to switch between an AJAX update mode, and an update mode relying on the standard form submission/browser refresh cycle.

T13: Power PHP Testing

Chris Shiflett
Geoffrey Young

Admit it - deep down inside, you know you should be testing your PHP applications. With all of the different PHP test environments and the daunting documentation, sometimes it is difficult to know where to start. This tutorial will help. The first step in testing is deciding what to test, so we will begin by offering a very simple (but not contrived) PHP application with identifying elements that lend themselves to testing - both unit tests and functional tests. Next, we will write some real tests using several of the existing PHP testing frameworks, including PHPUnit, Simple Test, phpt, and Apache-Test. In all fairness, we are biased - we think Apache-Test is hands down the best testing environment for PHP applications, offering a rich set of test writing tools while also providing a pristine, self-contained, and automated testing environment. So, the bulk of the tutorial will be spent learning how to write tests using Apache-Test and exactly what it means to have such a powerful tool at your fingertips. Along the way, you will be learning standard, insightful testing idioms that are universally helpful, regardless of the framework or even the language being used. Not using PHP for web applications? Never fear - most of the techniques you will be learning apply to the command-line PHP interface as well. But, for the unconvinced, we will be showing how to apply what you have learned to stand-alone scripts as well. All in all, you will leave this tutorial with some real-world testing skills that you will find immediately applicable to your day-to-day PHP work. And, you'll have some fun, too.

T14: Deep Comprehension of XPath and XSLT

Cliff Schmidt

This tutorial starts by ensuring students really understand how XPath works. Combining a thorough look at the XPath data model with lots of illustrative examples, the instructor will arm students with the skills to design and debug the most complex XPath expressions. The tutorial then takes the same approach with XSLT by emphasizing the fundamental process model of XSLT with more examples. Finally, the remainder of the tutorial will describe most of the features of XSLT, including recursive use of named templates, sorting, grouping, combining multiple documents, and extension functions. This tutorial has been taught at several past conferences and never fails to leave students with a much deeper understanding of how XPath and XSLT work, drastically reducing future debugging time. During the three hours we will start with a simple, but insightful, Hello, World! example, followed by reviews of both the XPath and XSLT specifications. Numerous exercises and example will be provided throughout the talk to ensure students are able to apply concepts mentioned in the specs to the real world. We will also briefly discuss upcoming features in XSLT 2.0.

T15: Building Projects with Maven

Eric Pugh

Maven is the first real competition to Ant in the Java build tools market, and Maven2 builds on that foundation. But Maven, with the concept of a Project Object Model, is much much more then just a build tool. Learn how Maven can provide a structure to drive the rest of your development environment. Learn how Maven compares to Ant. We'll dissect some different usages of Maven in some popular open source projects including Maven itself, XDoclet, and Geronimo. You'll leave knowing how to build ANY maven project, and how to confidently setup both basic projects as well as large multi project based builds.

T16: Taming Apache Cocoon

Gianugo Rabellino

Apache Cocoon is a very powerful framework providing solid solutions for a wealth of different scenarios, ranging from traditional web publishing to EAI. It has however a tendency to scare people away due to the impressive amount of code, components and configurations. This tutorial aims to dissipate any fear about Cocoon's daily use. By covering almost every aspect of Cocoon in a "teaching to fish" way, it will tell users how to: install, maintain and debug Cocoon; write efficient sitemaps; perform multi-channel publishing; use the Cocoon form framework; master the next web revolution: continuations and flowscript; extend Cocoon with custom components

T17: Building an Enterprise Portal with Apache Portals and Jetspeed-2

David Taylor

This session is an introduction to standardized JSR-168 portlet development using open source projects from Apache Portals. Starting with an overview of the Apache Portals project, the top level projects at Apache Portals are briefly introduced (Jetspeed 1, Jetspeed 2, Pluto, Bridges, WSRP4J, Graffito). Next, we present a tutorial on developing several portlet applications compliant to the Java Portlet Standard. The portlet applications will be based on technology found at Apache Portals including the Struts, PHP and Perl Bridges, SSO (Single Sign on) and Graffito (the CMS/Portal integration project). After deploying the portlets, we give a tour of the portlets running inside of the Jetspeed 2 enterprise portal, as well as an overview of the Jetspeed 2 features. In closing, we discuss the component architecture and integration possibilities of Jetspeed 2. (Roger Ruttimann and Ate Douma will be presenting the sections on bridges and SSO development.)

T18: Practical mod_perl

Philip Gollucci

mod_perl 2.0 supports all the mod_perl 1.0 features and brings a whole lot of new functionality such as protocol and filter handlers, improved configuration access, threads support and much more. This tutorial will get you up to speed with the new features, in addition to reviewing the old ones.

T19: Axis 2 Tutorial

Deepal Jayasinghe

The Axis2 project is the successor of the Axis SOAP project. Going forward from the highly influential Axis project, Axis2 aims to become the new gold standard for SOAP stacks.The architecture of Axis2 is highly flexible and supports much additional functionality compared to Axis.Axis2 is build around an XML object model called AXIOM. AXIOM provides a JDOM like simple API with the underlying structures build on a deferred model via a StAX-based pull parsing API. Additionally AXIOM allows one to stop building the object model and to directly access the underlying parse stream. The architecture of Axis2 supports convenient integration of Web services protocol implementations such as Apache WSS4J and Sandesha. It also features a highly flexible model to support for MTOM.While Axis2 attempts to preserve as many concepts of Axis as possible, due to the radical architecture of Axis2, there are many changes. In this tutorial we will briefly discuss the architecture and then discuss how services can be implemented or invoked using Axis2.Examples of handlers and modules will also be given to explain the pluggable architecture of Axis2.

T21: Apache Geronimo for Developers

Bruce Snyder

Apache Geronimo is the newest certified J2EE implementation on the market and developers need a jumpstart guide to ramp up as quickly as possible. Understanding how to exploit the features of Geronimo is key in becoming productive. Some of the most common issues for developers surround the configuration of services within the application server. A few of the most common services include JDBC pools, JMS topics and queues, logging and security. In addition to configuration, the deployment of enterprise applications, web applications is also critical and somewhat different in Geronimo. This session will demonstrate how to configure some common services in Geronimo as well as how to deploy applications in Geronimo. After attending this session, developers should be able to begin using Geronimo for application development and become part of the Geronimo community.

T22: Rapid application development with Maven and Turbine

Henning Schmiedehausen

As foundation of the Apache Jetspeed project, Jakarta Turbine has a long proven track record as the base of successful portal and content management applications. The current version of Turbine is well suited for rapid prototyping of web applications and deploying them in a servlet container. This talk gives an overview of the features and the facilities that Turbine offers to web application developers, demonstrates the usage of Jakarta Maven as an integrated build tool to rapid prototype a small web application and shows the integration with other Jakarta projects like Velocity and Torque.

T23: Advanced Cocoon: Flowscript and Forms

Ugo Cei

This tutorial introduces two new and powerful features of Apache Cocoon. The first one is the continuations-based Flowscript, which promises to revolutionize the way web applications are traditionally designed and developed. The second one is the Cocoon Forms framework, an extensible framework for developing web forms which adheres to Cocoon's founding paradigm of "Separation of Concerns" and makes the most out of HTML forms thanks to sophisticated, AJAX-enabled widgets. While each can be used separately, taken together the Flowscript and the Forms framework enable the development of very complex user interactions, while keeping code clean and properly modularized. The tutorial will show how to download, configure, and install Cocoon to develop a form-based application, going from simple use cases to richer ones, incrementally adding more advanced features along the way.

T24: SpamAssassin Tutorial

Daniel Quinlan

SpamAssassin is perhaps the most widely deployed anti-spam tool in the world and has long been the gold standard for spam filters. It's open source, extensible, flexible, and very effective. This tutorial will give you the tools you need to make SpamAssassin work well for your site and your users. Topics covered will include: how SpamAssassin works and the SpamAssassin filtering model, SpamAssassin installation and set-up, writing your own rules, debugging problems, analysis and diagnostics, optimizing SpamAssassin performance, the development process, and how to get involved. Also discussed will be current anti-spam best practices that are important for both senders and receivers of email.

T18: Practical mod_perl

Philip Gollucci

mod_perl 2.0 supports all the mod_perl 1.0 features and brings a whole lot of new functionality such as protocol and filter handlers, improved configuration access, threads support and much more. This tutorial will get you up to speed with the new features, in addition to reviewing the old ones.

T26: Subversion Tutorial

Brian Fitzpatrick

This tutorial will cover the details of using Subversion in open source development, including making the transition from CVS, Subversion's differences from CVS, and finally, using Subversion features not found in CVS. The latter part of the tutorial will focus on more advanced features such as branching and merging as well as how to leverage these capabilities in a collaborative environment. The ASF is in the process of converting its CVS repositories to Subversion, so be sure to come and get a jump on this excellent new tool!

PL01: Opening Plenary

Ken Coar

This is the opening session of the conference, providing a roadmap for the next three days and mentioning last-minute changes to the programme.

MO01: What's new in Apache HTTP Server 2.2

Paul Querna

Apache HTTP Server 2.2 is an incremental improvement over 2.0, focusing on new features. Authentication and Authorization has been refactored, allowing combinations that were previously impossible. Improvements in HTTP Caching and the new Event MPM can provide even better performance. The Proxy modules have been revamped, and now support Load Balancing and native Tomcat/AJP Proxying. mod_ssl added support for TLS Upgrade within HTTP and a builtin distributed SSL Session Cache.

MO02: Apache Harmony

Geir Magnusson Jr.

Apache Harmony is an incubating Apache project with two goals: first, to create an open source, compatible implementation of J2SE 5 under the Apache License, and second, to create a broad community around open source J2SE to create a modular implementation architecture. This talk will focus on the state of the project, and near and long term project roadmaps.

MO03: Apache Containers

Henning Schmiedehausen

Containers and component based architectures are the most recent trend in Software development. The Apache Software Foundation offers various containers which differ in maturity, feature sets and fields of application. This talk gives an overview featuring Excalibur (mature, IoC, Avalon based), Oscar (in incubation, OSGi R4 spec) and YAAFI (stable, IoC from the Jakarta Fulcrum project).

MO04: The Zen of Free: Deriving a General Model for Open Source

Simon Phipps

When people say "open source is fine but how do you make money?" you know they haven't grokked the Zen of Open. This keynote describes the 'virtuous cycle' model of open source. It explores which licenses and business models work and which don't, what the 'signature triangle' of an open source community looks like and why open source advocates aren't communists.

MO05: Intro to WebDAV

Rich Bowen

WebDAV allows for file transfer on top of HTTP. This can be used to manage web content, as a replacement for FTP, or even as a network file system. We will talk about how to install and configure mod_dav on Apache HTTPd, and what tools are available for managing content over DAV.

MO06: Introducing Apache Gump 3

Leo Simons

An introduction to Apache's continuous integration server. Apache Gump is a python-based program that is responsible for nightly compilation of the majority of the ASF source code, linking the very latest development versions against each other. This talk starts with a review of continuous integration concepts and then provides an overview of Gump's unique features and architecture. We'll take a look at how to set up a gump installation. After that we'll focus on what you need to know to get your project (whether its build system is based on make, Apache Ant, Apache Maven or something else) built by gump, guided by plenty of examples. No specific programming experience is required besides familiarity with one or more build management tools such as Ant.

MO07: Portals@Apache: Standards and the Portals Projects

Carsten Ziegeler

In the last years the interest for portals has increased. Two standards for developing portals are a key factor: the JSR 168 (Java portlet API) and WSRP (Web Services for remote portlets). This session introduces these standards and shows their potential. The second part of this session presents an overview over several portal related projects at Apache: the Apache Portals Project is hosting most portal related projects like Jetspeed, Pluto, WSRP4J, Bridges - but of course other projects like Cocoon or Struts are included as well. You will get an overview helping you in choosing the best Apache open source solution for your portal project.

MO08: Open Source for Business and Profit

Jim Driscoll

Jim Driscoll, manager of Sun's GlassFish Project, will discuss the process of Open Sourcing existing projects for a major corporation. Topics include selling the concept, determining ROI, and when to go FOSS and when not to go FOSS. Additional topics will include external marketing of a newly FOSS'd project, creating and selling the new FOSS processes to internal engineering, and setting up credible governance structures. We'll also briefly touch on license choices. Specific choices that Sun has made for it's Open Source projects will be used for examples.

MO09: Clustered logging with mod_log_spread

Theo Schlossnagle

Logging is one of the most commonly overlooked aspects of managing web architectures. Logs provide crucial information on traffic, trends, visitors and, most importantly, unexpected behaviour. Troubleshooting malfunctions and understanding trends in real-time is much more difficult in a clustered environment. A concise, unified logging infrastructure is crucial. This session will introduce mod_log_spread and the glorious things that can be done with it.

MO10: Content and Document Management Ecosystem

Christophe Lombart

This session is an introduction to the ECMS concept and it related technologies. After this session, you will get more information on the content market, application types (CMS, portal, DM, DAM, ...), architecture and standards. This session will also present the different ASF projects (Jetspeed, Jackrabbit, Slide, Lucene, ...) which can be used together to build a more powerfull portal cms plateform.

MO11: Embedding Apache Pluto

David DeWolf

Apache Pluto is the reference implementation of the java portlet specification (JSR-168). This session introduces Pluto's container architecture and discusses how to embed pluto into a web or enterprise portal in order to provide support for JSR-168 compliant portlets. The session will explore projects such as Geronimo and Jetspeed as examples of applications which embed pluto in order to provide portlet support.

MO12: Behind the Scenes of the Apache Software Foundation (Part 1)

Lars Eilebrecht
Cliff Schmidt

This presentation will give you everything you always wanted to know about the Apache Software Foundation (ASF), but were afraid to ask. It will show you that there is more than just the Apache web server, and provide you with information on how the ASF works. The difference between membership and committership, who decides what, how elections take place, the technical infrastructure, project management committees, and the philosophy behind the incubator. Come and see behind the scenes of the Apache Software Foundation and its many projects.

MO13: URL Mapping

Rich Bowen

When a request is made to your Apache Web server, Apache goes through several steps to figure out what content it is going to give you in response. This talk focuses on three aspects of this process: Directory indexing, which is the process of Apache delivering a default document from a directory, or a listing of the files in that directory; Content negotiation, which is a grossly underused feature that allows you to serve different content to different users, depending on their preferences; and URL rewriting, implemented by mod_rewrite, which is the process of modifying a URL as it comes in. Other aspects of URL mapping include Alias, ScriptAlias, Location, ErrorDocuments, and Redirect directives, which will be covered in passing on our way to the other topics.

MO14: Advanced Lucene

Grant Ingersoll

Lucene is a high performance, scalable, cross-platform search engine that contains many advanced features that often go untapped by the majority of users. In this session, designed for those familiar with Lucene, we will examine some of Lucene's more advanced topics and their application, including:

1. Term Vectors: Manual and Pseudo relevance feedback; Advanced document collection analysis for domain specialization
2. Span Queries: Better phrase matching; Candidate Identification for Question Answering
3. Tying it all Together: Building a search framework for experimentation and rapid deployment
4. Case Studies from CNLP: Crosslingual/multilingual retrieval in Arabic, English and Dutch; Sublanguage specialization for commercial trouble ticket analysis; Passage retrieval and analysis for Question Answering application
   
   Topics 1 through 3 will provide technical details on implementing the advanced Lucene features, while the fourth topic will provide a broader context for understanding when and where to use these features.

MO15: Apache James - The Java Mail Server

Henning Schmiedehausen

The Java Apache Mail Enterprise Server (a.k.a. Apache James) is a 100% pure Java SMTP and POP3 Mail server. This talk introduces the James Server and shows its unique Mailet API which can be used to build custom mail processing pipelines in pure Java. Based on Apache Avalon technology, James can be configured and extended to match different project and product requirements.

MO16: Behind the Scenes of the Apache Software Foundation (Part 2)

Lars Eilebrecht
Cliff Schmidt

Part 2 of the Presentation:

This presentation will give you everything you always wanted to know about the Apache Software Foundation (ASF), but were afraid to ask. It will show you that there is more than just the Apache web server, and provide you with information on how the ASF works. The difference between membership and committership, who decides what, how elections take place, the technical infrastructure, project management committees, and the philosophy behind the incubator. Come and see behind the scenes of the Apache Software Foundation and its many projects.

MO17: Introduction to mod_rewrite

Rich Bowen

mod_rewrite is one of the most powerful, and least understood, modules that come with Apache. This talk will introduce you to the process of crafting a rewrite rule, using many examples and common problems. After this session, rewrite rules will be scientific formulae, rather than magical incantations.

MO18: State of the Web Services Union

Davanum Srinivas

Web services are moving from the disruptive technologies category to the main stream IT must-have category. So the challenge is how to keep up with traditional vendors and offer a cutting-edge platform at the same time for various scenarios. We will look at the evolution of the projects at ws.apache.org, their currrent status, future plans. Discuss decisions that led to where we are. Talk about paths that lay ahead and how to get there. We will also cover topics like how we try to keep the community together, how we allow room for experiments, how to band together and cut releases etc as well.

MO19: Apache MyFaces - Open Source JavaServer Faces

Matthias Wessendorf

JSF (JavaServer Faces) is now a well-known and widely accepted standard in the J2EE landscape. If you are still wondering what JSF is and how it can be used to build robust and easy to maintain applications for the web this presentation is for you. JSF is introduced with a discussion of what it is and how it works. You will understand why we have JSF as well as how it works. Next up we cover the Apache MyFaces implementation of JSF and some of the really cool extras you get from using MyFaces. These extras are fileupload, tree, calendar, scrollable and sortable table, ajax components and custom validators, to name only some. Also there is built in support for Tiles, which allows you to compose web pages niftily. Another big plus is support for Cell Phones through its WML RenderKit. Since JSF is not bound to the servlet world, you’ll see how to use MyFaces applications inside of a JSR 168 portlet container. This session is supported with lot’s of examples to demo the cool things you can do with JSF and MyFaces. Attendees will discover JSF and how to use it practically to build web applications.

MO20: Your Open Source Strategy Sucks!

Gianugo Rabellino

Open Source in corporate environments is much more than grabbing a package and installing it. Even in Open Source, "failing to plan is planning to fail": learn how you can make the most out of your Open Source experience by finding out how to persuade your boss that Open Source is a good thing, how to identify the right Open Source solutions to your needs and how to participate in online communities and get all the support you need. This talk will try to give the audience an overview of the most used Open Source business models and provide a few hints to avoid pitfalls.

MO21: Power Regular Expressions

Neal Ford

Regular expressions should be an integral part of every developer’s toolbox, and have existed for decades, but many developers don't understand how important regular expressions are, or how to take full advantage of this powerful mechanism, either through command line tools, editors, or in their development. This session shows how to fully exploit regular expressions. The session covers regular expressions from the beginning through to advanced usage, both in Java and in tools that support regular expressions. We will begin with the basic premise of how regular expressions work, then show how to take advantage of the RegEx libraries built into Java and other platforms. Along the way, we will cover how to use wildcards, escape characters, meta-tags, character class operators, look-aheads/look-behinds, and how to use the "greedy operators" effectively. This session is packed with real examples of regular expressions (including a game show with no fabulous prizes).

MO22: Roller: An Open Source Blogging Platform

David Johnson

Roller is the open source Java blog server that drives the popular blogs.sun.com, jroller.com and numerous other blog sites. Currently making its way through the Apache incubation process, Roller is built on a host of Apache technologies including Struts, Velocity, Lucene, Jakarta Commons, XML-RPC and more. This overview, a primer for Roller users and contributors, covers the Roller feature set, architecture, lessons learned, project status and future plans.

MO23: AJAX in Apache MyFaces

Martin Marinschek

AJAX (Asynchronous JavaScript and XML) is a new, very interactive and dynamic techonology to build web applications. With AJAX, you load only parts of a page upon a request, and leave the other parts of the page unchanged. This session covers the basics of AJAX and its inclusion in JavaServer Faces. It goes on demonstrating the AJAX components Apache MyFaces brings along and how to use them in highly interactive web-applications. Finally, it outlines the technology to build your own AJAX components for JSF and Apache MyFaces.

MO24: Business Tips for the Open Source Consultant

Will Glass-Husain

Many open source gurus fund their work by opening a one person consulting shop. They quickly find out that technical expertise is important but only one piece of the puzzle. This session will provide a whirlwind tour of how to build a successful consulting business. First - the philosophy. We will discuss the essentials: how to provide top-notch service, get repeat business, and keep costs low. Second - tips and techniques. This includes how to bid and price a project, what to include in a contract, how to communicate with a client and how to handle disputes. Third - when to expand. Namely, the pros and cons of hiring or partnering with other people. As a whole, you will gain insights in how to use your expertise to make customers happy and earn a great living.

TU01: Single Source Publishing with Apache Forrest

Ferdinand Soethe

Apache Forrest harnesses the power of Apache Cocoon to build a single source publishing framework, based on common standards (xml). It is easy to use and extend to suit a wide variety of publishing needs. Learn how to get started with Forrest in few easy steps. A closer look at the design concepts behind Forrest. See that it can be easy to publish a single document to very different target media (Web, print, speech, presentation slides) and in a consistent and uniform way. Find out about 'smart' slide presentions you can create with Forrest. Take a tour of input-plugins for MS-Office, OpenOffice and other common formats learning how to integrate different document- and data sources in a common corporate design. Discover Forrest's potential to quickly embed dynamic data from local and remote systems.

TU02: Performance Analysis of Apache Derby

David Van Couvering

The Derby team at Sun has done some extensive analysis of the performance of Derby. In this session we discuss the tests we ran, what we uncovered, and some of the changes that we have made and are planning to make to Derby to address some of the issues we found.

TU03: New (and old) Trends in Web Application Security

Christian Wenz

There is material (articles, books, talks) about security everywhere, however this does not seem to help; new vulnerabilities in web applications are found every week. One possible explanation for this: most of us have been through boring presentations about web application security, including lame demos that do not frighten anyone. So this presentation uses a different approach: Old hacking attempts with demos that really hurt, and new innovative attempts to attack sloppy code. If you have been to this session, you really want to do that overdue security audit of your website.

TU04: XML at the ASF: The XML, WS, and Cocoon Projects

Ted Leung

This session is an introduction to the ASF projects available for working with XML. Each project will be covered with an overview and example application areas. For applicable projects, a brief demonstrations of the project will be included. Most of these projects are Java related.

TU05: Lenya and Jackrabbit Make a Fine Couple

Michael Wechner

Despite the fact that Lenya offers various methods through Cocoon to connect to all kind of repositories, the data abstraction isn't as unified as would be desired. Here comes JSR-170 to the rescue. Jackrabbit is the reference implementation of JSR-170 and has been started as an incubation project in 2004. This session explains how Jackrabbit is and will further be integrated into Lenya. Examples will be given and hands-on experience described.

TU06: Apache Derby Security

Jean Anderson

You might find an Apache Derby java database anywhere you look -- on servers, workstations, notebooks, laptops, kiosks, CD ROMs, in your email, on a shelf, in your desk drawer. Unlike high-end enterprise databases that host machines in locked machine rooms, most Derby databases won't be behind locked doors. Derby provides security features that are specifically geared for this mobile environment, including user authorization, authentication using a variety of schemes, support for running with a Java 2 Security Manager, and database encryption. This session describes each feature and provides an example.

TU07: Apache 2 mod_ssl by example

Mads Toftum

A series of practical examples aiming to teach the basics of securing a website with modssl. Topics include creating certificates, configuring Apache httpd, and a full blown example of using client certificates to create a secure extranet. Prior knowledge of setting up Apache httpd is necessary.

TU08: Intro to XSLT

Chris J. Davis

XSLT -Extensible Stylesheet Language Transformations, give you the ability to style and convert XML to any number of human readable formats including PDF, XHTML, et al. In this session we will cover XSLT syntax, CSS incorporation as well as take a look at some of the tools available for converting XML using XSLT.

TU09: Cosmo and CalDAV: Open Source, Standards-based Calendar Sharing

Brian Moseley

CalDAV is the latest attempt to standardize the communication between calendar clients and servers. Based on Apache's Tomcat and Jackrabbit projects, Cosmo (OSAF's calendar and sharing server) allows people to interoperably read and write each others' calendars with applications such as OSAF's Chandler, Apple's iCal and Mozilla's Lightning and Sunbird. Join us to learn more about CalDAV and how you can operate and even contribute to the development of an open source, standards-based calendar server for your family, community, workgroup or enterprise.

TU10: Dealing with Enterprise Database Challenges In OO Applications

Clinton Begin

This presentation will focus on database challenges that object oriented developers often face in an enterprise environment. Object Relational Mapping (ORM) tools are not ideal for all databases, and therefore alternatives must be sought. In this discussion, we’ll focus on using the iBATIS Data Mapper to achieve similar advantages as provided by an ORM tool, but without some of the complications that can arise from an object relational mapping approach. The iBATIS Data Mapping framework is a popular alternative to ORM tools, while being a complementary addition to any architecture.

TU11: Secure Web Gateway with mod_security and mod_proxy

Kiran Mendonce

With the growing attacks on the servers, especially web servers, there is a need for a secure web gateway for a site hosting multiple web servers. Application gateways provide more control and flexibility as they understand the application protocol. This session describes how a secure software gateway can be built with Apache using modules mod_security and mod_proxy. This also discusses the future work that could be done to enhance the features to provide more robust features such as handling other protocols like FTP and SMTP.

TU12: Pragmatic XML Security

Hans Granqvist

This session discusses various aspects of XML security. From the origins of XML, encryption, and signing, it goes on to cover WS-Security and how it is used in practice. For each complexity introduced, real-world code solutions will be shown. The session will use Apache TSIK, a Java toolkit currently in ASF incubation, for all examples. The emphasis is on giving practical information to solving real-world problems with XML security.

TU13: Cocoon - One Hour Portal

Carsten Ziegeler

Apache Cocoon is the ideal solution for integrating different data sources, while, at the same time, providing the information to different devices in different formats. You will get an overview of building portal applications with Cocoon and get an insight on the portal architecture. The Cocoon portal supports the standards, JSR 168 and WSRP, and provides more functionality like portlet communication and integrating complete applications as a portlet.

TU14: Introduction to MINA

Trustin Lee

Apache MINA (A Multipurpose Infrastructure for Network Applications) is a Java network application framework that enables users to develop stable and high-performance network applications rapidly. MINA is ideal for developing protocol servers such as LDAP, SMTP, HTTP, Kerberos, and many more. In this session, the lead developer of the project explains what MINA is and how MINA can help you to implement simple and complex protocols. An overview of MINA patterns and constructs will be discussed to kick-start attendees so they can begin to use MINA.

TU15: Apache authentication

Rich Bowen

Authentication and Authorization are the process of finding out who is visiting your Web site, and determining whether they should be permitted to see content. Apache ships with two authentication methods, and there are dozens of others available from the module repository. This talk covers Basic and Digest authentication, several alternate authentication methods, and will delve into what's involved in writing your own access control module using mod_perl.

TU16: Java-XML Binding Approaches at Apache

Thomas Dudziak

In this session, we will give an introduction into the possible approaches to binding Java objects and XML documents in general, when they are applicable and what are their pros and cons. Additionally, the Java-XML binding projects in Apache (commons-betwixt (with commons-digester), JaxMe, and XMLBeans) will be presented including short, concise samples of how they are used.

TU17: Cocoon Blocks

Daniel Fagerstrom

The Cocoon community is working hard on the next generation of Cocoon. The most important improvement is that most of the functionality will be packaged in so called blocks. The blocks architecture is built on the application framework OSGi, which also is used as the basis for the plugin architecture in Eclipse 3. A block can contain libraries and resources. At a higher level, blocks can contain reusable components. It will be possible to choose what component framework to use for each block, so that one block can contain e.g. Spring managed components and another Pico managed ones, that can cooperate seamlessly. What is maybe most exciting is that a block can contain a whole extensible web application. This will lead to a new level of application reuse. An application can be built by extending an application block and by just overriding the resources that needs to be modified. This is analogous to extension in object oriented languages. The blocks based Cocoon will put an end of todays huge download, you just download a small Cocoon core and use a deployment tool to download, configure and install the blocks that your application happens to need. In the talk the new architecture will be described and examples will be given on how applications can be devloped with the new tools.

TU18: (A) Maven is Your Friend

Carsten Ziegeler

A main task in software development is building and managing your project. Maven is a very powerful tool that takes care of many reoccuring tasks. Instead of writing a build script for your project, you simply describe the project (location of sources, documentation and unit tests; library dependencies etc). Based on this description Maven provides a variety of tasks - including web site generation with metrics about your source and results of unit tests. This session gives an introduction into Maven and it's possibilites. At the end of the session, you will know under which circumstances using Maven increases your productivity and when other build tools might be better suited.

TU19: New Modular Authentication Architecture in Apache 2.2

Brad Nicholes

If you have taken a look at Apache 2.2 lately, you have probably noticed the addition of a number of new authentication modules. In reality the number of authentication methods haven't changed, they have just been rearchitected to provide much more power and flexibility. What used to be a single authentication module in Apache 2.0 has been broken down into authentication types, providers and authorization methods. Now rather than being stuck with a single authentication module, you can mix and match the type of authentication with various providers and authorization methods. In fact with the new mod_authn_alias module you can create your own custom providers and reuse them anywhere within your configuration. This presentation will show you what you need to know about the new authentication module architecture and how to configure it in ways that were previously not possible.

TU20: Struts 2006: An Embarrassment of Riches

Ted Husted

Apache Struts is a hotbed of activity. Struts Classic 1.3, Struts Shale, Struts Ti, Struts OverDrive. Why so many frameworks? How are they different? Why are they all called Struts? Which is the best choice for my next project? In this session, we step back and look at Struts through a wide-angle lense.

TU21: Slicing and dicing REST with Apache Cocoon

Gianugo Rabellino

REST is becoming more and more important as the down-to-earth web services alternative that "just works". The REST world is generally built upon web based infrastructures that produce and consume XML, and Cocoon is a top notch web application leveraging all the latest and greatest in XML technologies. As a result, REST and Cocoon fit like hand in glove. This talk will guide the audience through theory and practice in using REST technology, including a number of real life examples showing how powerful the Cocoon/REST combination can be.

TU22: Extending Apache SpamAssassin using Plugins

Michael Parker

The plugin architecture in Apache SpamAssassin allows for near unlimited growth in SpamAssassin's capabilities. This session will discuss some of the common plugin hooks and how to create and use plugins with Apache SpamAssassin. In addition, we'll cover some example plugins to tackle existing problems or feature requests people are having today.

TU23: Secure Single-Sign-On with Apache Directory and Apache Kerberos

Enrique Rodriguez

The lead developer of the Kerberos protocol provider for the Apache Directory will discuss the use of Apache Directory as a "realm controller" for Linux and Windows machines. This talk will provide an overview of the Kerberos and Change Password protocol workflow. Significant time will be spent on the configuration of trust relationships and the configuration of both Linux and Windows machines to use Apache Directory as a Key Distribution Center (KDC). Hint: those attending this session should be interested in network authentication ("single-sign-on") using Kerberos realms. Prior experience with Kerberos is recommended.

TU24: Shale: The Next Struts?

Craig McClanahan

Come and get an early look at the next generation of web application frameworks. One that is based on the recenty standardized JavaServer Faces APIs, and focuses on adding value, rather than redundantly implementing features that JSF already provides. Shale will run on any compliant JSF implementation, including the one being developed by the Apache MyFaces project. It also includes many features that Struts users appreciate, such as supporting client side validation and the Tiles framework.

PL03: ApacheCon Lighting Lottery Talks

Brian Fitzpatrick
Wilfredo Sanchez

Abstract being edited for display.

WE01: Scalable Apache for Beginners

Aaron Bannert

As computers become cheaper, websites are being deployed on increasingly powerful systems. Taking advantage of these high-powered systems is crucial to the success of any deployment. Since Apache is one of the most versatile web servers available, the default configuration rarely works well for a production environment right out of the box. However, minor configuration changes often result in huge performance benefits. In this session we will jump right into Apache configuration and identify performance-related directives. We will also look at how operating systems affect performance, discuss ways to monitor the health of your system and troubleshoot common problems, and look at some tools for measuring your site's performance. Benefits and tradeoffs of both Apache 1.3 and 2.0 (including the multithreaded "worker" MPM) will be presented, as well as some next-generation improvements that lie ahead. Strategies for dealing with static and dynamic site content will be discussed. Various load balancing strategies for improving reliability and site performance will also be explored. This session is applicable to the novice and intermediate website administrator.

WE02: PHP and Unicode: A Love at Fifth Sight

Andrei Zmievski

Historically, PHP has provided only marginal support for multilingual text processing and i18n. This session covers the work being done on the native Unicode support in PHP, based on the ICU library. We will cover language changes and enhancements, migration issues, examples, and future directions.

WE03: J2EE Development with Apache Geronimo

Aaron Mulder

This session introduces Geronimo from the perspective of a J2EE developer. Do you have experience developing J2EE applications, but no idea how to get started with Geronimo? Or perhaps wondering whether you about the roles of Tomcat and Geronimo? We'll cover the Geronimo server's features, installation and management, deployment plan syntax, included tools, debugging options, and more. Specific development topics include configuring and deploying web applications, database connection pools, security realms, EJBs and CMP, JMS connections and destinations, and web services. We'll also look at the logs, the management console, how to hook Geronimo up to your build scripts and IDE for deployment and debugging, and how to hook Geronimo up to the Apache Web server to handle dynamic content.

WE04: From CGI to mod_perl 2.0, Fast!

Philippe M. Chiasson

This session will give Perl CGI writers a crash course in porting existing CGI code to mod_perl-2.0 Learn about the benefits of mod_perl vs. plain CGI scripts. Discover the differences and peculiarities of Perl code running under mod_perl. See the various ways in which CGI scripts can be made to run under mod_perl as well as the multiple new kind of runtime-errors and common conversion pitfalls. Hear about ModPerl::Registry and ModPerl::PerlRun, 2 CGI accelerating modules. See how ab can be used to quickly measure speed improvements.

WE05: HTTP Caching and Cache-busting for Content Publishers

Michael Radwin

Large web sites need to provide a personalized experience while keeping page-download times and bandwidth costs low. Radwin discusses when to use and when to avoid HTTP caching, and how to employ cache-busting techniques most effectively. Radwin also explains the top 5 caching ad cache-busting techniques for content publishers.

WE06: Large-Scale PHP

Rasmus Lerdorf

PHP has become amazingly popular due to its simple pragmatic approach to solving the web problem. Sometimes we forget some of the complexities that are inherent to any web application. When building large-scale web applications with PHP you need to harness the strengths of PHP and apply it correctly. In this talk Rasmus will give a brief overview of the new features in PHP5 including the new unified XML implementation which brings PHP's pragmatism to XML handling followed by a step-by-step approach to correctlt designing, implementing, securing and optimizing your PHP code for large-scale applications.

WE07: Building Highly Available Applications with Geronimo and Derby

Emmanuel Cecchet

In web application, the database usually becomes the performance bottleneck as well as a single point of failure. This talk will show you how to build end-to-end highly available web applications using Geronimo, Derby and Clustered JDBC (c-jdbc.objectweb.org). It will also discuss how to build highly available embedded Apache Derby applications and how to use C-JDBC as an open source driver to replace the IBM DB2 JDBC Universal Driver for Derby for a completely open source configuration. C-JDBC provides clustering techniques at the JDBC level and can be used in two different configurations with Apache Derby. Further, C-JDBC does not require changes to your existing database application. We will present different Geronimo, C-JDBC and Derby configurations offering various application usages with associated performance, fault tolerance and availability tradeoffs. The session will also feature a demonstration of C-JDBC’s administration tools using the xPetstore demo running with Geronimo. Involved technologies are Apache Geronimo, JDBC, C-JDBC, Apache Derby and JMX (for admin).

WE08: mod_perl for Speed Freaks!

Philippe M. Chiasson

This session will provide mod_perl users with various ways to identify and solve performance problems with mod_perl 2.0 application code. Covering a variety of tips and techniques including: persistent DB connections, cached DBI statements, reducing memory usage by deploying shared memory, module preloading techniques, avoiding importing of variables and global variables in general, forking and subprocess overhead, memory leakages detection and prevention, tuning Apache configuration directives for best performance by benchmarking the scripts, object method calls vs. functions, sending compressed HTML, performance of print calls and buffer flushing.

KN03: Panel: Inside Apache

Lars Eilebrecht

A panel discussion among various officers and directors of the Apache Software Foundation. Topics discussed will include the current status of the Apache Software Foundation, how the ASF operates, licensing, the incubator project, and other topics related to the ASF and its many projects.

WE09: Hacking Apache HTTP Server at Yahoo!

Michael Radwin

Since 1996, Yahoo has been running Apache HTTP Server on thousands of servers and serving billions of requests a day. This session reveals the secrets of how Yahoo gets maximum performance out of minimal hardware by tweaking configuration directives and hacking the source code. Radwin will cover topics such as reducing bandwidth costs, extensible logfile format and rotation schemes, dumping core gracefully, and how to avoid the dreaded MaxClients, Max/MinSpareServers, StartServers configuration nightmare.

WE10: Consuming Web Services Using PHP 5

Adam Trachtenberg

As we move into the world of Web 2.0, PHP developers must increasing include Web services in their toolkit of skills. This session covers how to implement REST and SOAP clients using the latest PHP 5 extensions, such as ext/soap, SimpleXML, and xsl. This is not an academic talk discussing theory and specifications. Examples show applications of popular Web services, including del.icio.us, eBay, and Google Maps. Don't be left behind. Come to this session and learn how to integrate Web services into your code.

WE11: Introducing Axis2

Eran Chinthaka

The Axis2 project, the successor of the Axis SOAP project, started in September 2004 with the goal of developing a next generation SOAP stack to serve as the core of the next generation Web services platform. The project started with a face to face meeting held in Colombo, Sri Lanka and released 0.9 version in July 2005. Our goal is to release v1.0 of Axis2 by August. Axis2 is centered around a high performance object model called AXIOM and is designed to be a very flexible SOAP engine support document-oriented, asynchronous communications as well as traditional RPC-style interactions. Axis2 has been carefully designed to allow other modules, such as Apache WSS4J (implementation of WS-Security, Secure Conversation and Trust) and Apache Sandesha (implementation of WS-Reliable Messaging) to be built on top of it and very easily integrated. This session will present the key concepts of the Axis2 architecture and provideinsight in to the next generation of Apache SOAP stacks.

WE12: The Future of Open-Source OSGi

Jeff McAffer

The OSGi (Open Services Gateway initiative) specification includes, amongst other things, a component model for Java. The specification has been around for a number of years and now in its fourth version. Recently the need for a modularity mechanism has come to the fore with JSR 277, the Apache Oscar project, the Eclipse adoption of OSGi, etc. This panel explores the issues facing open source implementations of OSGi by bringing together leaders from the various open source projects (e.g., Apache, Eclipse, Knoplerfish, Oscar) to expose their hopes, dreams and deepest fears.

WE13: Building Scalable Web Architectures

Aaron Bannert

Modern web architectures combine Open Source building blocks with increasingly powerful commodity hardware to achieve massive scalability. How do they do it? This talk will examine some common LAMP and LAMP-like architectures, cover performance tips and tricks, and discuss common pitfalls, all with real-world examples. Powerful troubleshooting tools and techniques will also be discussed. Building blocks discussed will include Linux/FreeBSD/OpenSolaris, Apache/Squid, PHP/Perl/Python/Java, Memcache/Spread, and MySQL/PostgreSQL. The discussion will cover a wide range of technical detail which should benefit both the beginner as well as the experienced LAMP architect.

WE14: Ruby for Java Developers

Neal Ford

Why would any self-respecting Java developer care about Ruby? And why does everyone keep talking about it? This session answers these questions and more. Ruby is a very expressive, powerful general purpose language that keeps gathering raves from industry luminaries. This session introduces Ruby, aimed specifically at Java developers. It covers Ruby syntax and philosophy, showing lots of code along the way. See how a 200 line Java application equates to 20 lines of Ruby code. In addition to syntax, this session shows networking, file I/O, web services, threading, and a host of other topics. The goal of this session isn't to get you to switch from Java. It makes you think about expanding your toolbox and adding Ruby for things that don't need a full-blown Java application. Along the way, the Ruby philosophy will make you Java coding better too.

WE15: The Open Service Bus

Paul Fremantle

The Enterprise Service Bus - or ESB - is an approach for integrating different systems across a network. This session will cover an ESB based on pure open source and Apache code. It will cover how to acheive the three major aspects of an ESB: connectivity, mediation, and management. The session will explore the use of Apache code including Axis2 and AXIOM as the core of a high-performance, lightweight, integration framework. We will cover: how to integrate disparate systems; how to mediate messages, including using XSLT, XPath, scripting, and Java; how to manage and monitor ESBs; how to support security, reliability, and transactions; and how to create an ESB.

WE16: Java Modularity Support in OSGi R4

Richard S. Hall

The OSGi core Framework has undergone more changes in the new R4 release than in any other since its inception. Behind these changes is the new focus on viewing the Framework as providing a modularity layer for Java. This has resulted from a growing interest to use OSGi technology as an application Framework for building extensible systems, such as application servers or plug-in-based platforms. This presentation will discuss the modularity-related changes to the R4 core Framework that were introduced to support such new usage scenarios.

WE17: Improving Web Performance with Dynamic Compression

Slava Bizyayev

In this session we'll talk about content compression on Apache server covering the following topics: Basics of the content compression, Examples of compressed files, Benefits of data compression in numbers, Apache modules for content compression, Features and configuration, Dynamic compression vs. Static compression, Latency benefits in graphics and numbers, Content compression on Google and Yahoo web sites, Recent solutions on top of the Dynagzip project (the Last Mile ISP, Internet Banking, Semi-Static Pages for Dynamic Content).

WE18: Cheap, Fast, and Good: You can have it all with Ruby on Rails

Brian McCallister

Ruby on Rails is a new web application framework which provides tools for everything from object/relational mapping to componentized views. It provides the architectural soundness of the Java Model 2 action/view frameworks with the rapid development and expressiveness of PHP. This session will teach you how to build sophisticated, scalable applications quickly using Ruby on Rails, the Apache Web Server, and PostgreSQL.

WE19: Achieving High Scalability in JBI with Apache JavaFlow

Ricardo Rocha

The new JBI specification (Java Business Integration, JSR-208) promises to deliver choice, flexibility and interoperability to enterprise application integration on the Java platform. This presentation discusses a powerful technique for achieving high scalability of Java-based business process orchestration under JBI. By using continuations -as provided by the Apache JavaFlow project- large numbers of long-running business process interactions can be handled by the JBI container without tying up valuable thread resources. Also, by serializing such continuations when feasible, it is possible for business process interactions to transparently survive application server restarts. The orchestration of asynchronous business process interactions by means of continuations defines a simple -but powerful- style of sequential programming that replaces complex REST or state machine-based programming. Continuations have been successfully used for driving complex web interactions on several platforms (Java, Ruby, Scheme). In the Java realm, in particular, continuations are supported by the Apache JavaFlow project and have been leveraged by Apache Cocoon.

WE20: Declarative Services in OSGi R4

Richard S. Hall

The OSGi service platform defines a framework for Java for executing dynamically downloaded services. The OSGi framework's focus on dynamically available services results in a complex new programming model for most developers, since application components may appear or disappear at any time. As a result, programming OSGi-based applications is more challenging than typical application development. To alleviate this situation, the OSGi R4 specification introduces Declarative Services and the Service Component Runtime. Declarative Services allow developers to declare service components and their dependencies in an XML file and leave the complex handling of dynamics to the Service Component Runtime. This presentation will discuss the issues behind service dynamics and how service dependencies are now managed by the Service Component Runtime.

PL04: Closing Session

Ken Coar

As the last session of the conference, the closing plenary gives delegates an opportunity to give feedback to the planning committee and the Apache Software Foundation. All delegates are encouraged to attend and speak up!