ApacheCon US Tutorials: Monday

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 how often the two are askew. We will discuss in detail three distinct but related problems in clustered web architectures:

Apache Cocoon is a very powerful framework providing solid solutions for a wealth of different scenarios, ranging from traditional web publishing to EAI. This tutorial aims to introduce participants to the power of Cocoon from a pragmatic daily use perspective; covering almost every aspect of Cocoon it will show 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. The tutorial will also illustrate how a number of real-world problems have been solved through the use of XML and Cocoon.

Apache Axis2 is blazing the trail by being a clean and extensible open source Web services platform. The architecture of Axis2 is highly flexible and supports many QoS functionalities such as reliable messaging and security. One of the most desirable features of Axis2 is the ease of use for developers. It includes a new deployment mechanism, a new client API and pluggable data binding frameworks. Axis2 can also be extended easily through modules, the new archive based extension mechanism. In recent performance tests, Axis2 came up high when compared with its predecessor Axis1, by 4-5 times. This is a hands on tutorial focused on leveraging Apache Axis2 to build enterprise applications. It will cover how Axis2 is used in the production environment, with advanced examples of using handlers , modules and services. Important topics such as embedding, security, reliable messaging, Spring support and scalability will also be discussed in-depth by walking through a real world use case. The tutorial aims to face head on, practical issues faced by users when dealing with real world applications.

Last year at the ApacheCon keynote with Tim Bray, Francois Orsini demonstrated the novel concept of embedding a database in a browser. This received a lot of attention as people saw how they could use this model to enable a whole new class of web applications. Many people asked for more guidance as to what this looked like and how they could do this themselves. In this tutorial we will show you how this works through the process of building a simple AJAX application that uses a local database. In this tutorial you will learn how to:

From an AJAX application, initialize, boot, and connect to a browser-embedded Apache Derby database.

Send queries to the database and display results

Issue database updates after each field exit, providing full recoverability of user data

Synchronize data changes between the embedded database and a back end database.

This will be a very interactive, hands-on tutorial, so please bring your computer. We will be sending registrants a list of what they need to have on their laptop in order to be able to work through the labs.

Experience with JavaScript, DHTML, Java and databases is advised but not required.

This session is a gentle introduction to Maven for those looking to use Maven for the first time. The general philosophy of Maven will be discussed along with Maven objectives, Maven principles, and What Maven Provides. There will also be a practical hands on exercises including creating your first project with Maven, creating your first application with Maven and using Maven Plugins. This session is geared toward those who have heard about Maven and what to see what Maven can do or those who have just started using Maven and want to get some hands-on experience.

With the popularity of Windows workstations, people want to use Windows for tasks such as local development of sites hosted on remote UNIX/Linux servers. Many get frustrated as they don't realize that platform differences mean that Apache behaves differently; others don't realize that the platform offers new opportunities which they would not have otherwise; and some are simply overwhelmed by the differences and do not know where to begin looking for a starting point. This tutorial will help you leverage the Windows/Apache HTTPD combination to the best of its abilities. Besides covering what is unique to the Windows platform, the tutorial will also cover other aspects where the Apache web server is different, such as security, CGI, and non-core modules. Participants are highly recommended to bring their own Windows system in order to actually perform hands-on tasks.

One of the most under appreciated aspects of the Subversion version control system is the fact that it's built as a collection of libraries that can easily be reused in applications far beyond those traditionally associated with version control. In order to make use of this ability, all you need to do is learn a little about Subversion's internals, and you'll be able to use its battle-tested versioning filesystem to hold whatever data your application needs. Starting with an overview of the Subversion libraries, you'll learn the basic APIs Subversion is built upon, and from there see how to make use of them in concrete examples of how the various libraries can be applied to different real world problems. Learn how to programatically create repositories, store data in them, search backwards in time through previous versions of a file, access repositories over a network, and much more. Examples will range from low level C code to higher level scripting languages like Perl, Python, and Ruby.

CANCELLED- Title: T09 - Apache iBATIS for Java

iBATIS is a framework for executing SQL statements, mapping domain objects to statement parameters, and mapping result sets back to domain objects. It is often seen as a competitor to Hibernate, although the two projects differ significantly in their goals. iBATIS is not, and does not claim to be, an Object-Relational-Mapper (ORM). iBATIS fits well into projects where a full function ORM is not a good fit - either for performance reasons or where there is a significant mismatch between an object model and the associated database schema. iBATIS is available for Java, .Net, and (coming soon) Ruby. iBATIS allows developers to focus on creating object models and performant SQL, rather than the mind-numbingly tedious job of writing database interaction code. This fast paced tutorial is designed to teach experienced Java developers how to use iBATIS for Java. The tutorial will be about half presentation and half hands on exercises. The tutorial will cover these topics:

Basic iBATIS setup

Writing your first SqlMap

Writing DAOs without the iBATIS DAO framework (coding directly to the SqlMapClient interface)

Leverage your hard-earned Struts experience in this three-hour hands-on tutorial. Learn how to intergrate existing Struts applications with the Next Big Thing: Struts 2. The tutorial covers migrating existing applications to Struts 2, with a focus on upgrading the most important asset of all: the grey matter between your ears..

This session is for those who want to leverage team collaboration techniques provided by Maven and related technologies like Continuum, The Maven Repository Manager. There will be a discussion of the challenges that teams face when developing software and how Maven can make these challenges easy to overcome. Maven's site management techniques can help teams provide visibility into their projects and help teammates see what's happening in near real time when site generation is automated. Continuous integration techniques will be discussed and Continuum will be used to demonstrate how you can track the pulse of your projects with little effort. Release management, which can often be difficult, will also be discussed and Maven's release management tools will be used to demonstrate how to relieve the complexity and burden of making frequent, dependable, and reproducible releases.

This tutorial will introduce the audience to OpenSolaris and it's Zones technologies. The tutorial will cover setting up multiple zones, each with a different application stack and configuration on the same server. This tutorial will demonstrate the consolidation of multiple uniquely configured webservers and the application stack onto a single physical server.

JSF has reached reality. Several frameworks and component libaries are already existing. This tutorial shows you a best of breed mixture. We cover the basic concepts of JavaServer Faces technology. After that, you build your first web application using JSF. We introduce lots of custom components from Apache MyFaces - an open source implementation of the JavaServer Faces specification - which will be integrated step-by-step into your web application. MyFaces contains cool extra components like calendar, upload, tree and AJAX-based widgets, to name only some. Advanced stuff like Portlet integration, usage of Struts Shale, Facelets and Spring integration are discussed as well. Attendees will get a very practial overview of what is possible with JSF today.

Apache ServiceMix is an ESB based on the JBI specification currently incubated at the ASF. This tutorial will first introduce ServiceMix and then give the basic material needed to leverage ServiceMix in a SOA context. This tutorial will cover:

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.

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 clean install of a current Apache Jetspeed-2 version pre-installed, and be prepared to develop Portlet code throughout the course of the workshop. We will go through a series of 8-9 portlet revisions ranging from a simple "Hello World" to a portlet demonstrating the use of multiple portlet modes, preferences, JSP Tag Files, JSP Expression Language, action processing and portlet URLs.

Tests make your life easier, and Apache::Test makes writing tests that execute against a live webserver easy - it takes care of configuring and starting the server, running your tests, stopping the server, and reporting back your successes (or failures). This talk will introduce the Apache-Test interface and detail what you need to know to get started.

CANCELLED- Title: TU7 - Jakarta BSF: Enter Scripting for Java

The next version of Java ("Mustang", a.k.a. "Java 1.6") introduces a scripting interface to the language which will not be available for earlier version of Java. By contrast the Jakarta "Bean Scripting Framework (BSF)" has been allowing full scriptability for Java 1.3 and up for many years. This tutorial introduces the Jakarta BSF scripting interface and demonstrates how easy it is for Java programmers to use BSF supported scripting languages (JavaScript, Jython/JPython, NetRexx, ooRexx, Jlog, and the like) for their purpose. This opens up a huge market opportunity (as can be seen by the proprietary Windows scripting by Microsoft). The nutshell examples will demonstrate how scripting languages can interact with Java as well, taking advantage of all of Java's functionality. Furthermore, applications that possess Java interfaces can usually be driven in a platform independent manner with the BSF technology.

In this tutorial attendees will learn techniques for creating robust, maintainable, scalable PHP and MySQL applications on top of Apache. Topics include best practice architectures for PHP and MySQL web apps, managing legacy applications and maintaining code, and testing and debugging in the Web 2.0 environment. Attendees should walk away with a better understanding of engineering web applications.

Apache Synapse is a key foundation for your SOA infrastructure. One of the key problems with SOA is managing diverse endpoints, services and messages as they flow through the system. Synapse sits between services on the network and does useful things. It can log and monitor, route and transform, translate and validate messages as they flow across the network. Synapse has a simple, easy to use configuration model closely based on available standards, including XPath, XSLT, and Regex. Out of the box Synapse does useful things like switching between WSRM and JMS, WS-Sec and HTTPS, XML and JSON, REST and SOAP. Synapse is a lightweight, high-performance pure open source Enterprise Service Bus and Broker. Built on top of Axis2 and Axiom, it supports both transparent proxying and an explicit gateway model. Synapse can be easily extended with additional mediators implemented as Java classes, classes managed by Spring etc. This tutorial will help you understand the core architecture and design of Synapse. It will answer such questions as: "how do I connect JMS and SOAP systems?", "How do I support new versions of services?", "How to route messages to the best available service?". We will examine the policy based approach and the proxy based approach and examine how best to enable RM and Security across your network. In addition to looking at the built in capabilities of Synapse, we will also cover how to extend it with new function and new rules.

The OSGi specifications are implemented by several open source communities including Apache Felix, Eclipse Equinox and Knopflerfish. These specifications provide a dynamic module system to Eclipse, Nokia phones, Enterprise servers (Apache Directory Server), BMWs, and numerous embedded and desktop applications. Many OSS groups are evaluating the use of OSGi. Components provide services that are dynamically discovered and bound to services from other components. This model allows for very efficient dynamic software architectures which are easily deployed and managed: dynamically without reboot. There are three open source implementations and many commercial ones. This tutorial teaches you how to leverage the OSGi dynamic module system in real world applications. Attendants should bring a laptop with the Eclipse 3.2 SDK installed to do a number of exercises with OSGi.

Apache Forrest provides a single source publishing system based on common standards to create Web and Print-Documents from the same document. It is easy to use and extend to suit a wide variety of publishing needs.

Learn how to set up Forrest in few easy steps.

Create first documents based on standard Forrest templates for How-To-Document, FAQ, and plain documents.

As part of this tutorial we'll take a closer look at the design concepts behind Forrest and 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.

Prepare yourself for a variety of media opportunities with communication skills that resonate with editors and analysts and help generate positive coverage. Learn how to craft, control, and bridge messages and gain confidence during the interviewing process. Present your position clearly and become more persuasive to effectively target editors and influence the analyst community. Hone your presentation techniques  from public speaking to analyst briefings through group coaching, individual interviews, and breakout practice sessions. Takeaways include identifying common mistakes and tips on how to avoid them, press do's and don'ts, analyst relationship management, developing thought campaigns, positioning previews and launch tactics, and more. A must-attend for those interested in promoting their Open Source project and becoming a resource for the media community at large.

ApacheCon US Sessions: Wednesday

Everyone talks about the speed of light, but have you actually measured it? Let's aim a laser beam across the room; we'll turn it on and off, and measure how long each pulse takes to travel across the room. It's a classic experiment, going back to Galileo, Roemer, Fizeau, and Michelson. Just one hitch: Special Relativity.

Along the way, let's try a few other physics experiments: find the speed of sound, see a dipole precess in a magnetic field, and perhaps tweak the Earth's magnetic field. All experiments performed without a net.

From independent developer programs, to small business IT environments, to mission-critical enterprise implementations, Apache-based technologies form the backbone of Open Source applications of all sizes. ASF President Sander Striker kicks-off this year's conference with the latest developments from The Apache Software Foundation, including its projects, Membership, community, and more.

This session provides an overview of Maven, a discussion of Maven’s principles, what Maven can provide for our development team and the benefits of using Maven. This session will be a balance of theory and live demonstration starting with a description of Maven’s powerful project object model (POM) and show how the use of POM alleviates many of the traditional burdens in software development. By the end of this session you will have gained enough familiarity with Maven to create, build, and manage your own projects with Maven.

The ESB term has become so hyped as to be meaningless. Apache Synapse is a project based on the maxim: "Code Talks": instead of hype, Synapse is based on delivering the most useful function needed to build and manage a distributed, interoperable Service Oriented Architecture. Synapse sits between services on the network and does useful things. It can log and monitor, route and transform, translate and validate messages as they flow across the network. Synapse has a simple, easy to use configuration model closely based on available standards, including XPath, XSLT, and Regex. Out of the box Synapse does useful things like switching between WSRM and JMS, WS-Sec and HTTPS, XML and JSON, REST and SOAP.

Synapse is a lightweight, high-performance pure open source Enterprise Service Bus and Broker. Built on top of Axis2 and Axiom, it supports both transparent proxying and an explicit gateway model. Synapse can be easily extended with additional mediators implemented as Java classes, classes managed by Spring etc. This talk will introduce the Synapse message mediation framework and how it could be configured and used to solve common enterprise integration scenarios. So come along and find out how to build an ESB the open way.

CNN.com is a high profile website with some unique performance considerations. We have developed several modules that have enabled us to more than double our web serving capacity while halving our actual number of web servers and bandwidth usage. We currently serve over 2 billion hits per day using Apache. We have learned many performance lessons.

JSF (JavaServer Faces) is now a well-known and widely accepted standard in the J2EE landscape. JSF is introduced with a discussion of what it is and how it works. You will understand both why we have JSF and how it works. 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, Tiles support, calendar, scrollable and sortable table and custom validators, to name only a few. Since JSF is not bound to the servlet world, you'll see how to use MyFaces applications inside of a JSR 168.

The ApacheCon Business Track addresses business, marketing and legal/licensing issues in Open Source over the course of three days. A panel of industry experts will open the Business Track by engaging in a lively discussion on the key issues affecting the industry, including:

Strategy, Staffing and Software

Competitive Advantage

Cashless ROI

Business Trends and The Emperor’s New Clothes

VCs, Angels, and Daemons

Moderator Sally Khudairi will create an interactive environment by including questions and comments from the audience throughout the 50-minute session

Effective software development organizations want their software development process to be automated, repeatable, and produce quality systems in a highly productive manner. Maven 2.0 is a popular open-source framework which tackles this challenge head-on by abstracting tasks and processes commonly performed across applications and can streamline many of the activities involved in building and maintaining software systems.

The presenters will highlight the enterprise capabilities of the Maven architecture and recommend best practices based on their implementation experience across a Fortune 500 rental car company. Specifically, this presentation will explore how Maven can be leveraged to achieve:

Repeatable and reproducible builds

Code and build reuse across an organization

Mature configuration management

Collaboration and communication across project teams

Promotion of project visibility

Pragmatic documentation

Standardization of process and technology

Audience members will gain an understanding of the capabilities of Maven, the breadth of its extensibility, adoption strategies, and best practices for effective use.

Apache ServiceMix is an ESB based on the JBI specification currently incubated at the ASF. This presentation will cover the JBI specification, ServiceMix specific features and how to leverage these features in an SOA context.

Since 1996, Yahoo! has been running the Apache HTTP Server on thousands of servers, serving billions of requests a day. This session reveals the secrets behind "yapache," Yahoo's hacked-up version of the Apache web server. Learn how Yahoo! gets maximum performance out of minimal hardware by tweaking configuration directives and hacking the source code.

Struts 2 is a web-based MVC framework that emphasizes simplicity and interoperability. Built on the familiar Action-centric approach of Struts 1, generation features reusable UI templates and themes, POJO Actions, annotation- configuration, JavaServer Faces support, native AJAX capabilities, robust server side validation, and much more. This session will cover the key features new version, paying special attention to existing Struts 1 developers.

Title: WE10 - Bringing Open Source Software Development Processes and Principles to the EnterpriseSpeaker:Brian BehlendorfTrack: Business

Enterprises have historically treated software as a fungible asset they can purchase off-the-shelf or that, if written in-house, has some inherent value that can be detached from the context it was written for and the community who wrote and used it. In contrast, the more successful open source projects have shown the value of socializing the practice of software development, of connecting the code to the community behind and using it, and the ongoing process of development. Enterprises today are learning from open source how to bring transparency and consensus decision-making to internal development, how to build sustainable developer and user communities around modular code, and how to make participation on public open source projects a regular part of their own development process.

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. In the last twelve months, new projects have been incubated, others matured rapidly and become the foundation for other Apache projects. This talk will show "what is there" in the ASF, cover the different concepts in the containers available and highlight their strenghts and weaknesses.

PHP has become amazingly popular due to its simple pragmatic approach to solving the web problem. The web problem has been changing and there is a lot of talk about Web 2.0 and the Programmable Web. PHP is more relevant than ever as people are combining web service components to build rich AJAX-driven web applications. In this talk Rasmus will cover the basic building blocks PHP 5 provides for building these rich applications with a heavy emphasis on performance.

A virus-scanning HTTP proxy between you and the web is becoming more commonplace. The presentation will first show how to put together a scanning proxy with just mod_proxy, mod_cache, and a custom output filter. The talk then will detail some of the inherent challenges in scanning HTTP data, including caching and performance implications, and expose some solutions to those challenges.

Over the last five years, a variety of frameworks for building Java-based web applications have been created. More recently, however, JavaServer Faces has become a standard part of the Java EE 5 platform, providing both a user interface component framework and the basis for a web application framework. It is possible to integrate JavaServer Faces components into many frameworks (including Struts). However, the resulting architecture leaves you with redundant implementations of many features (such as navigation and validation). A framework that uses JavaServer Faces extension points, on the other hand, would provide a leaner and easier-to-use base for building webapps. Shale is such a framework. It leverages JavaServer Faces extension points to provide additional functionality (application event callbacks, dialogs with conversation-scoped state, annotation-based functionality to reduce configuration requirements, support for remoting), while leveraging the standard application controller facilities of JavaServer Faces. This session will introduce the basic features of Shale, and discuss the roadmap for its future development.

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 webserver, and provide you with information on how the ASF works. It will show you the difference between membership and committership, point out 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.

The Apache Harmony project is building a compatible implementation of the Java SE platform. Founded with the intent of collaborating with other FLOSS Java SE communities the project has two primary goals: - to create a full implementation of Java SE including JVM, class library and tools - to implement the above by using a modular and component-containing architecture for the JVM and class library This session will cover the background of the project and describe the community and technical issues encountered to date, provide a status report, and demonstrate the current codebase.

The Apache HTTP Server powers some of the busiest sites in the world, so when your web site takes off and becomes popular, you're in good hands when you use Apache. This session covers tuning the Apache HTTP Server for performance. We will discuss server performance monitoring and benchmarking. Then we will cover configuration options that affect performance, system sizing and operating system tuning. Finally, we will discuss caching dynamic content with mod_cache.

Shale is a modern web application framework based on JavaServer Faces. Java Persistence Architecture is the successor to "Entity Beans" in the EJB2 architecture. Both of these frameworks focus on improving ease of use for application developers. What could be better than a synergy between the two technologies, that leveraged the benefits of both? Come to this session to learn how to leverage these technologies together, as well as understand how the same principles can be used to leverage other existing persistence frameworks (such as Hibernate) in conjunction with JavaServer Faces.

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 webserver, and provide you with information on how the ASF works. It will show you the difference between membership and committership, point out 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.

PHP Axis2 and the Axis2/C Firefox extension are examples of Apache Axis2/C used as the base to provide Web service capabilities in diverse platforms. This kind of integration is a reality, not only because it is written in C, but also because Apache Axis2/C has been written platform independent with portability and integration in mind. This session will help you understand how you could use the Apache Axis/C API to embed it in to your platform to enable Web Services. The session will use sample use cases from both the PHP Axis2 extension and Axis2/C Firefox extension to demonstrate how integration could be done effectively in a short period of time.

As your web site grows in popularity, you will get to the point when one server doesn't cut it anymore. You need to add more boxes, and this session discusses several approaches to scaling out. We will cover webserver load balancing, SSL offload and separating application tiers. We will also discuss how to configure the Apache HTTP Server to front Apache Tomcat servers and how to load balance between Tomcat servers. Finally, we will deal with Java VM and database tuning.

State saving in JavaServerT Faces (JSF) technology is a hot topic--it is the single most important configuration setting for making your applications perform like they should. This presentation tells you what the speakers have learned in implementing state saving in Apache MyFaces--in using state saving in their applications, profiling their performance, and discussing the results with their user community. Expect to learn lots about how state saving in JSF works and how to use JSF for applications that scale.

ASF Director and Executive VP, JimJagielski, will announce and describe the ASF Corporate Sponsorship program. This program is designed to allow for Corporations and Organizations to provide direct financial support to the ASF in an official and recognized fashion. The types of sponsorships available, and the specifics of each will be provided. An open Q-and-A session will conclude the talk.

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.

Native Unicode support is the main feature in the upcoming PHP 6. Come to this session and find out what this means for you and how you can take advantage of it. This talk will provide an overview of the most salient features of the Unicode support and illustrate the new internationalization features with a variety of demos on topics such as:

Despite the widespread availability of POSIX operating systems, writing C code that is portable to a wide variety of Unix operating systems is still a challenging problem, even for an experienced developer. Add in the need to run on Windows, Netware, OS/2, and even BeOS and you've got something that's beyond all but the most operating system agnostic among us. But all is not lost for the cross platform C programmer, you can make the task manageable simply by building on the right foundation, the Apache Portable Runtime. The Apache HTTPD runs on all of these platforms, and the collective knowledge of the developers that made that possible has been condensed into a C level API that lets you portably take advantage of the best platform specific abilities on each system, while still remaining portable enough to run without them. Learn how to portably go from "Hello World" all the way up through a multithreaded network server, gaining a working knowledge of APR's API via complete examples who's lessons you can easily use in your own applications.

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 explains 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.

The basic goal of marketers and strategists is change. We accomplish this by futzing with a few basic levers; examples are the "The Four Ps"product, positioning, promotion and price. However, as markets mature, they tend to ossify, increasingly indifferent to manipulations of levers that move less and less and only in certain directions. And so we strive for break-out market disrupters and stifle yawns. Open source disrupts this torpor, setting everything in motion and upending markets and practices that haven't budged in years: traditional competitors can become de facto colleagues (e.g, Sun and IBM work together on Derby in the Apache community); going for "I win/you're screwed" loses; better technology does matter; product lifecycles start to look more like fruit flies', with beneficial mutations appearing in months vs. years; and doing marketing and strategy in this swirl is pure F-U-N. In this session, I'll share my experiences and observations gathered from the past two years while shaping and implementing Sun's open source database strategy and show how Sun benefits from its use of open source products and participation in their communities. You'll get a sense of how open source can open up opportunities where there were none before, why open source makes good business sense for end-users and vendors ("free" is only one part of it), and how you too (!) can join in the fun.

The two most important changes in PHP 5 are improved object-oriented features and new XML extensions. This session provides an introduction to both by demonstrating the two in combination. Using the real-world example of eBay's APIs as the basis of a case study, you'll create a more usable interface to a SOAP-based Web service with the help of magical methods, SPL, and ext/soap. Working together these tools simplify your code and make it easier to manipulate external data sources. If you've ever wondered what's the purpose of the oddly named methods, __get(), __set(), and __call(), this is the session for you. Likewise, even heavy users of the SOAP extension are bound to learn an undocumented trick or two.

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.

In this presentation I will cover the history of the Open Management Consortium, including the organizations current status, goals and aspirations. I will then cover the benefits of/to the Apache community in working hand in hand with the Open Management Consortium to open source the process of open standards. The presentation is aimed at anyone and everyone who is interested in furthering the openness of management standards by bringing these conversations out into the open and driving interoperability between system administration and systems management tools. I will also cover the three major initiatives the Open Management Consortium will be undertaking in 2007 including a ground breaking on a new open source systems management R&D datacenter, the creation of a software forge, and the push to create a better licensing model for “blended” software.

WebDAV is a http-based filesystem, a replacement for FTP, a way to exchange calendars, a handy way to manage your web content, and so much more. Learn how to configure your Apache web server to do DAV, and how to connect to it with a variety of different client applications.

Apache 2, although available for 4 years, had had slow adoption due to misconceptions about how ready it is. In particular, folks think that it doesn't play nice with PHP. Of course, this is hogwash. In this talk, we'll show you the reasons why you should move to Apache 2.2 immediately, if not sooner - stuff that you can't live without, and can't do on 1.3 no matter how hard you try. This will be slanted towards PHP user, showing many of the cool things that are now possible with PHP in 2.2.

Apache FOP is the most popular XSL-FO implementation on the market. It is used to create documents in PDF, PostScript and other formats. With the imminent release of Apache FOP 1.0, this session will give an overview of what Apache FOP can do today. It will show you how to approach integrating FOP into an application and point to the existing tools around you that can help you with this task. You will get tips how best to organize the development of your documents/stylesheets, which editors can help you and what their limits are. Furthermore, you'll learn when the use of XSL-FO makes sense and when not. A small case study will also help illustrate the use of Apache FOP in a web environment.

This sessions presents various tips and tools to identify problems area in existing code and help in improving it's performance. Learn to measure how well your existing code is performing and common ways to improve it. Discover build times and run-time options to improve overall performance. Use various tools to inspect your code and generate metrics on it's performance. See tools in action, like Apache::VMonitor, Devel::Profiler and others.

The presentation shares feedback from IT organizations regarding their challenges and success stories in implementing a "managed" adoption of open source. The talk covers key CIO concerns around licensing, community, governance model and project health. Case studies around the successful implementation of Open Source adoption programs will be discussed along with specific technologies, process models and internal ROI metrics.

Mod_python provides a highly scalable and powerful Python-based foundation for developing web-based applications. This talk will discuss the mod_python project and provide simple examples of using mod_python's essential features. Having attended this presentation you should be well on your way to understanding and being able to use mod_python.

Java is a flexible language for coding database procedures and functions. With Java you can ship code to the data rather than vice versa. Learn how to eliminate unnecessary network traffic and push business logic as close to your information as possible. Harness Java's expressiveness, portability, and rich tool support to the tasks of filtering and transforming large data sets. This session discusses how to deploy Java code inside SQL databases. Topics include: 1) a comparison between Java and SQL/PSM, 2) invoking open source libraries inside your queries, 3) sending applications to the database, and 4) a survey of popular databases which host Java code. Examples use Apache's open source Derby database. This session assumes some familiarity with writing SQL SELECT and INSERT statements as well as some familiarity with JDBC, the Java interface to relational databases.

Trinidad is the new name for Oracle's donation of the ADF Faces. Trinidad comes with very high quality components, a dialog framework, as well as personalization, skinning capabilities and JSF extensions. Trinidad features include: file upload support, client-side validation, partial rendering of a page (AJAX-style), data tables, hierarchical tables, color/date pickers, progress indicators, menu tabs/buttons, wizards, internationalization and accessibility. In summary there are more than 100 production ready components. This session will introduce several of these goodies and shows howto use them in your Java EE project.

One of the more interesting and practical features to come out of the Apache 2.0 redesign effort is output filters. While mod_perl has had the ability to filter content for years, it wasn't until Apache 2.0 that we could truly leverage that power to its full extent. Here, we will introduce the new and simple streaming API and show how powerful just a few simple lines of mod_perl can be.

Open Source developers often voice the frustration of not having enough visibility of their projects. Gain insight into communication strategies that help to reach beyond your peers and immediate fanbase and break through the noise in the marketplace. Learn how to clarify your message and define who you are against competitive projects. Improve your media skills to mitigate the reality of overworked reporters and make your efforts more credible to analysts and the community at large. Raise your profile and let the world know how good you really are. Sell the sizzle, and sell the steak.

Although Apache 2.2 appears to include a number of new auth modules, in reality the modules have just be rearchitected to provide much more power and flexibility. Rather than being confined by a single auth module, you can now mix and match the type of authentication with various providers and authorization methods. Recently authorization went through a similar transformation and added AND/OR logic so that 'Require' rules could be applied in ways that were previously not possible. This session will discuss the new auth architecture of Apache 2.2 and peek into the future of authorization.

The 10.2 release of Apache's Derby database engine release contains many new features, this presentation will give an overview of each new feature with examples of its use. Features covered will include Jave SE 6.0/JDBC 4.0 support including ease of development items, online backup, XML support, GRANT/REVOKE, updateable ResultSets, SQL optimizer directives and many other minor features.

Roller is the open source Java blog server that drives the popular Sun's employee blogs at blogs.sun.com, IBM developerWorks blogs, 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, XMLRPC and more. This overview, a primer for Roller users and contributors, covers the Roller feature set, the all-new Roller 3.0 page models/macros, Roller 3.0 architecture, lessons learned, project status and future plans.

The JavaServer Faces (JSF) API is an excellent foundation for building secure Web applications because of its component-oriented nature, carefulness surrounding data validation, and numerous extension points. Apache myFaces builds on this strength by providing components which offer built-in protection against many of the OWASP Top Ten attacks including form parameter tampering and cross-site scripting. In this presentation, we’ll review how myFaces protects against these attacks and move on to explore JSF extensions you can deploy to provide complete protection against the OWASP Top Ten, including forced browsing, information leakage in select boxes, and unauthorized method execution. Specifically, we’ll look at centralized approaches to ensuring that every field and form is properly validated, a phase listener and view handler to prevent forced browsing and assist with detection of session hijacking, a customer converter and component to hide sensitive information such as IDs in menu options, and a JAAS permission checker for component actions (event handler methods).

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. Building on a popular talk at ApacheCon 2005, this tutorial will cover the essentials of creating a successful consulting business. First, we will discuss the key principles: provide top-notch service, seek out repeat business, be productive, and keep costs low. Second, we'll discuss practical issues: How to sell a project, how to price your services, what to include in a contract and how to handle disputes. Third, we'll look at specific case studies and discuss the tricky business issues that might arise. Bring your current business conundrumswe expect active discussion following the presentation. With a little luck, you will gain insights in how to use your expertise to make customers happy and earn a great living.

One of the new features of Apache 2.2 is the transition of LDAP authentication from experimental status to a standard Apache module set. This presentation will show just how powerful LDAP authentication can be. It will also show how the LDAP authentication provider and authorization methods can be mixed with other authentication types to provide a much more powerful and robust authentication service. Discover the many different ways in which mod_authnz_ldap can be used to authenticate users through the use of LDAP filters and attribute matching. See how the connection and credential caching built into mod_ldap can be used to improve LDAP authentication performance. Finally learn how to mix and match LDAP authentication and authorization with various other providers and methods to produce an authentication service that works for you.

Apache Derby is a fully-featured, small footprint, 100% Java relational database that can run within the same VM as your application. These features enable it to do be used in ways and environments you wouldn't normally expect to be able to use a relational database. In particular, Apache Derby can be embedded in an AJAX-style JavaScript application running in your browser. Last year at ApacheCon Francois Orsini demonstrated this unique way of using a database that enables a whole new class of web applications. You can use the database to cache or even store data on the client, improving the performance of web applications and taking them off of the leash of an Internet connection. In this session we will go into great detail showing exactly how to build such an embedded application, walking through the code, showing how to use NetBeans to build a web application with a local storage, and demonstrating one way to synchronize your data between the embedded database and the database running behind the web server.

The Atom Syndication Format and the Atom Publishing Protocol are used more and more to organize and publish information about the most disparate subjects: from weblog posts to search engine results, to REST-ful interfaces to storage systems. This talk will provide an overview of some Open-Source Java tools that enable you to consume and publish data using the Atom Syndication Format and the Atom Publishing Protocol: Apache Abdera, ROME and Roller. Emphasis will be placed on how using Atom helps building distributed systems that properly implement the REST style of architecture.

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, skinning, AJAX and integrating complete applications as a portlet.

Single sign-on is the holy grail of authentication; Kerberos is becoming the industry standard for network authentication. This presentation will look at current solutions for implementing enterise-wide single sign-on for web sites using Kerberos and the Apache HTTP Server, including the "mod_auth_kerb" module. Some of the problems with these solutions will be discussed, and work on new approaches will be covered.

As an official Apache project, more people are using Derby as their database management system both during development and in production, making Derby performance optimization key. This presentation focus on how to use Apache Derby in order to get the best performance out of it and at the same time ensure durability of the data stored in the database in case of failures. The presentation gives an overview of the main architectural components of Derby and how these influence the performance. It focus on how different configuration options both with regards to hardware, operating system and Derby itself influence the performance and data durability. Often trade offs have to be made when selecting between performance and which failure scenarios that can be handled with out loss of data. The presentation shows how to configure Derby to avoid loss of data in case of software, operating system, hardware and power failures. It includes tips and tricks for the application programmer on how to best program against Derby in order to maximize the performance. The different configuration options and programming tips are illustrated by performance examples. The presentation will also include a small section giving some examples of how Derby compares to other Open-Source databases (MySQL and PostgreSQL) with regards to performance.

The so-called "Semantic Web" is a vision for an evolution of the web where web sites expose data not only for direct human consumption (as it is mostly the case today) but also for specific software agents to consume, aggregate and enrich on behalf of humans. In this presentation, I will show an outline of this vision, together with a simple and concise description of each W3C recommendation (such as RDF, OWL and SPARQL) that are involved and how they are supposed to work together. I will also show the differences and similarities between this and other models for purer-data interchange on the web (such as "web 2.0" and "atom/rss") and will demo existing solution that are based on semantic web technologies.

Apache Cocoon is one of the most popular Java frameworks for building complex web applications. The latest version has been in development for the last years and provides many new functions and features making the development of web applications even easier. This session introduces the new features by providing examples and best practices. The roadmap of Cocoon and further planned features are discussed as well.

Speakers are given 30 seconds notice to give a five minute talk on a topic of their choice. Topics can be of any sort so long as there is a relation to the ASF or to ASF projects and are submitted at the beginning of the session to be drawn at random.

When a request is made to your Apache 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 is the process of Apache delivering a default document from a directory, or a listing of the files in that directory. Content negotiation is a grossly underused feature that allows you to serve different content to different users, depending on their preferences. URL rewriting, implemented by mod_rewrite, is the process of modifying a URL as it comes in. Other aspects of URL mapping include Alias, ScriptAlias, Location, ErrorDocuments and Redirect, which will be covered in passing on our way to the other topics.

Two standards for developing portals are currently available: the JSR 168 (Java portlet API) and WSRP (Web Services for remote portlets). This session introduces these standards, shows their potential and future directions (WSRP 2.0 and JSR 286). The second part of this session presents an overview of 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, Struts or Tapestry are included as well. You will get an overview helping you in choosing the best Apache open source solution for your portal project.

OSAF hosts two closely related calendar server projects: Cosmo, a CalDAV+Atom protocol server, and Scooby, a rich AJAX web calendar client. Cosmo and Scooby work together and with desktop clients like Chandler, Sunbird, iCal, and Evolution to provide an environment for managing personal calendars across multiple computers and devices and for sharing calendars between individuals and groups. Members of the Cosmo and Scooby projects will discuss today's features and architecture (including the use of JCR and Apache Jackrabbit), the role of standards and interoperability, and the roadmaps to release.

Apache Geronimo is the latest open source application server to achieve J2EE 1.4 certification, making it ready for adoption in the Enterprise. It is now a real contender in the open source application server market and offers a unique architecture making different open-source projects pluggable and capable of building customized stacks. This session will present an overview of Apache Geronimo, the project and community, its architecture, its major open source components, and how to configure and use the application server. The presentation will cover a technical birds-eye-view of Geronimo's unique J2EE components and concepts such as the kernel, plugins and how to effectively use Apache Geronimo in your organization.

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.

Basics of international copyright and patent laws, with a focus on U.S. laws, but also addressing European laws and the Berne Convention. Talk will briefly address derivative and collective works (see "Advanced IP Law" talk for deeper discussion).

The JSR-286 Expert Group is working on the new Portlet Specification 2.0 since early this year. Already a first early public draft has been released last July, and the second, 'feature complete', early public draft is planned for October 2006, leading up to a final release planned for mid 2007. The Expert Group plans to align the Portlet Specification with J2EE 1.4, integrate other JSRs relevant for the portlet (like JSR-188), and align with WSRP 2.0. This presentation will provide an overview of the progress made so far and focus on the enhancements and new features for Portal and Portlet Developers struggling with the restrictions and limitation of the current JSR-168 Portlet Specification 1.0. Topics which will be addressed are:

With all the buzz about AJAX and rich user interfaces on the web, does your current project feel left out? Is your project being overlooked because of the flash of your competitors? Is it too late in the game to play catch-up? Are you worried that your project can't use AJAX techniques because your clients use Stone Age browsers? This presentation will look at 5 Simple and Backwards Compatible ways to add some AJAX enhancements to an existing application without having to do a major overhaul and without forcing your user's to upgrade their browsers. To show that these techniques work in real life we will be examining recent work being done on Krang, an Open Source CMS, using the Prototype and Script.aculo.us Javascript libraries. Krang is used at several large corporate organizations with required legacy browser support. This does not stop users with modern browsers from having a modern experience. Not only will your user's experience be enhanced but your application will run faster and use less bandwidth. And it's easier than you think.

Apache Geronimo is the first major application server to include a structured plugin architecture. Geronimo plugins have a click-through install process including validating prerequisites, automatically downloading and installing required dependencies, and potentially upgrading existing server functionality in-place (no restart required!). But what can you do with app server plugins? In this session, we'll look at the innovative ways to use Geronimo plugins, including integrating Apache projects like Jetspeed and Directory, unified deployment of applications including J2EE features and ESB services, hot deployment of scheduled jobs and reports, cloning servers from developer to developer, migrating applications from dev to test to production, and more. You'll learn how to leverage Geronimo plugins to increase your productivity for J2EE, lightweight, and SOA applications.

This session will cover multiple aspects of creating a high performance Apache SpamAssassin installation. Covered topics include methods for increasing speed performance, increasing efficacy performance and usablity. In particular, we will discuss strategies for speeding up message scanning, customizing rules and scores to maximize local catch rate, and tools for allowing users to manage their own configurations.

Every open source project runs into people who are selfish, uncooperative, and disrespectful. These people can silently poison the atmosphere of a happy developer community. Come learn how to identify these people and peacefully de-fuse them before they derail your project. Told through a series of (often amusing) real-life anecdotes and experiences.

ApacheDS now has LDAP stored procedures and triggers. The world of Relational Databases has enjoyed the benefits of stored procedures and triggers for many years now. These tools of the integration layer make the relational database very appealing to developers for many reasons. Code can be located close to data for mass manipulation. Referential integrity can be managed using triggers. The introduction of these constructs within an LDAP Directory makes LDAP more appealing. Further more it will lead to the development of new applications using LDAP. This lecture discusses these constructs with respect to LDAP, their implementation within ApacheDS, and how they can be used to build new LDAP backed applications.

Many projects use at least some of them - the Jakarta Commons libraries. Small reusable libraries simplifying the day-to-day work of thousands of java programmers. But over time the jakarta commons project has grown and the number of components makes it harder and harder to keep track. This session will try to give an overview of the components available and how the Jakarta Commons community is organized.

Title: FR16 - Snapshot of Apache AnnouncementsCategories: New TechnologiesLevel: All

You've heard the terms. You've seen the debates on the blogs. But what does it really come down to? What are SOAP and REST? Is one actually better than the other? Is SOAP too complex? Is REST too simple? Does Amazon's REST API really get 5 times more usage than the SOAP one? Does this mean you shouldn't bother with SOAP? This talk will pit the REST and SOAP against each other in an attempt to come to some answers as to which one you should choose!

Apache Tuscany is an effort undergoing incubation at the Apache Software Foundation, sponsored by the Web Services PMC. Apache Tuscany provides implementations of the Service Component Architecture (SCA) specifications and related technologies such as Service Data Objects (SDO) and Data Access Service (DAS). The overall goal of the project is to provide an open-source runtime platform to simplify the implementation of SOA-based applications in various programming languages such as Java, C++, JavaScript or BPEL. Tuscany integrates with well established Web Services and server technologies such as Apache Axis2, Apache Tomcat and Geronimo. This session will explore how the Tuscany runtime works. We will work through coding examples and show how to use Tuscany to implement service components, build, deploy and run composite SCA applications and communicate with Web Services. We will present how to get involved in the development of Tuscany and embed the Tuscany runtime or extend it to support additional component types, programming languages, bindings and communication protocols. We will also cover the latest developments and ongoing work with the Tuscany code base, with a demonstration of some of the latest features.

The Apache Directory Server (ApacheDS) is an LDAP server which uses the X.500 basic access control scheme based on the X.500 administrative model. We will cover the X.500 administrative model and the basic access control scheme. We will show ApacheDS users and administrators how to create access control information to safeguard LDAP entries within ApacheDS. Users will be shown how to configure ApacheDS to use this AC scheme over the default static AC scheme that comes out of the box. Advanced topics such as the delegation of authority for access control policy within your directory will also be covered. The session will cover all the information you need to apply fine grained access control to entries within ApacheDS.

OSGi technology for Java was originally envisioned as a dynamic service platform for home gateways, but has spread to all forms of Java development, as witnessed by Eclipse adoption and the Apache incubator Felix project. OSGi technology fills a void in the Java platform as a dynamic modularity and component layer. Recently, the JCP has introduced three different JSRs (277, 291, and 294) that are intimately related to OSGi technology and/or Java modularity. This presentation will provide an overview of OSGi technology, introduce the Apache Felix incubator project, and discuss the relationship and issues surrounding JSRs 277, 291, and 294.

Many enterprise applications are required to be highly scaleable and highly available. Clustering is one approach to achieve these performance requirements. In this talk we will cover what clustering is and why its important. Specifically we will cover how to achieve these requirements of applications deployed to Apache Geronimo. In particular we will cover load balancing with Apache HTTPD to a cluster of Geronimo web tier servers to achieve high availability. We will cover failure scenarios and how the server will respond as well as what the user will see in their browser (if all goes well the user won't know). In addition to the web tier clustering we will go into the current state of clustering that is available for the rest of the Java EE stack.

Perl is a language flexible enough to let you make your own decisions about how to use it. You can optimize your code for performance, for compactness, or even for entertainment value. But what if you want to optimize it for not getting support calls in the middle of the night about strange behavior on your web site? What if you want to optimize it for spending your Saturday at the movies instead of in the debugger? This talk will show you how to choose a dialect of Perl that suits your preferred level of risk. It won't be a simple prescription, but you will learn why avoiding certain constructs can lead to fewer nasty surprises and less difficulty integrating code written by a team. A little planning and a willingness to choose practical solutions over magic can really pay off in reduced debugging time. Perl gives you a lot of rope, but it's not too late to learn some new knots.

Detailed discussion of derivative/collective works, fair use, dynamic linking and interface case law, and how these issues are addressed in contribution and distribution policies by leading open source organizations, such as the Apache Software Foundation and the Eclipse Foundation.

With the arrival of Cayenne in the Apache Incubator, the ASF has now five different projects to map SQL data to Java objects and vice versa: Torque, OJB, iBatis, JDO and Cayenne. This talk introduces all of them and shows their strenghts and weaknesses compared to each other.

This unique session will address the most pressing issues that have been raised by the user community since Axis2 1.0 release. Key areas such as POJO support, Spring support, embedding, JAX-WS support etc will be discussed. The focus will be on providing the status with respect to these key issues and the critical "Know-How" to get you started on these areas.

The Tapestry web application framework has been getting a lot of buzz in the wider community. Come to this session to learn firsthand what's so special about the Tapestry approach and how quickly and easily you can put together cutting-edge Web 2.0 applications by leveraging available Tapestry components.

Title: FR29 - All you wanted to know about Open Development community building but didn't know who to askSpeaker:Stefano MazzocchiCategories: CommunityLevel: Beginner

In this presentation, I will show, explain and analyze several patterns in community building for open development projects that I've come across during my 9 years of involvement in the ASF. The presentation is aimed at those who want to understand how to seed and bootstrap communities as well as those wanting to analyze existing communities for improvement and/or signs of behavioral changes. I will also present some of the software tools over the years that I've written to help the job of community mentor and observer.

Passwords are notoriously insecure and yet we use them hundreds of times daily. What can we replace them with? We've seen certificates, PKIX, various "Single Sign-on" schemes, and Shibboleth, but delegated user authentication hasn't spread to Internet-scale, and there are still a few unmet requirements, particularly for HTTP-based applications. Some current standards work includes SAML profiles (Liberty Alliance), TLS Attribute Certificate extensions, and tying Kerberos into more protocols. This talk will cover use cases, various possible requirements, security threats, possible solutions, and the current status of various standardization efforts.

Apache has hundreds of projects that cover a wide range of topics. These projects need to compile, build and link against each other, be backwardscompatible and forwards-compatible, and implement multiple versions ofa external specifications. The build, test and release management environment at apache is as complex as these environments get. And it works surprisingly well. This talk gives a high-speed overview of the technologies and processes that make our builds and releases tick. We take a case-study-based look at the use of tools such as Apache Maven, Apache Ant, Apache Ant, JUnit, release signing, the mirroring system, SVN-based workflow, and more.

Over the past few years, many agencies of the U.S. government have embraced web services. This move has provided challenges in the areas of security in the areas of identity management, access control, policy enforcement, and performance and availability. During this time, there have been several pilot projects in the U.S. Government which have used Apache WSS4J and Apache Axis to secure their web services. This talk will provide an overview of these projects, discussing security architecture considerations, and will focus on standards such as WS-Security, SAML, and XML Signature. The presentation will provide an in-depth focus on the use of Apache Axis and Apache WSS4J in these projects, and the speaker will provide Java code and detailed messaging examples throughout the presentation.

Even though Ruby enthusiasts often disdain everything that has to do with Java, many Ruby programmers are in fact retrained Java programmers who would like to bring with them some of their favorite libraries and toolkits when they cross over. And indeed there's an incredible wealth of Java software, most of it open source, that brilliantly solves a huge range of problems. It would be great to be able to exploit this richness even when using Ruby as your main language. The session will show, with a hands-on approach and plenty of samples, how to make the worlds of Ruby and Java coexist, either by having Ruby code call Java code, or viceversa, in-process or inter-process. Bridging, running Ruby on the JVM, and remoting approaches will be introduced and their respective merits and shortcomings discussed.

The Apache Software Foundation created a website to provide a directory of information about it's various projects during 2006. Allowing the projects to remain their autonomy was an important consideration, so a distributed solution was sought. Using RDF as the data source allowed each project to manage their own information and XSLT allows the files to be easily parsed and the site generated. This talk will explain how the RDF format was developed and show how the various elements of the website are created.