Brian Pontarelli

By Brian Pontarelli

Learn how to manage service oriented architecture applications over time. This talk will focus on how to deploy a SOA application and version components individually. It discusses the finer points of upgrades and how to architect your system so that each deployment doesn't mean stopping and starting "the whole world" and how to attempt to achieve the "four nines" (99.99%) uptime ideal.

Attendees should walk away with a complete vocabulary for how to discuss versioning of applications, numerous architectures and designs that can assist in versioning, and well balanced, unbiased overview of four different types of SOA (WebServices, Tuple Spaces/JavaSpaces, Jini and ESB).

By Brian Pontarelli

This presentation covers all the basics of the Jini platform, which has recently been transitioned from Sun to Apache. This presentation will show how to construct a service based application using Jini as well as how the Jini network is structured and deployed. In addition, a demonstration of the cool Jini features such as dynamic discovery, recovery and provisioning will be given.

Attendees are encouraged to bring laptops which will be able to participate in the demonstration Jini network. JDK 1.5 is required to run the demonstration application.

By Brian Pontarelli

Groovy, a dynamic language specifically for Java, is making headlines because of its ease of use and speed of development. The best part about Groovy is that any Java application can use it via embedded Groovy. This talk will cover everything you need to know to embed Groovy in you Java application.

In this talk we will cover all the basics of embedding Groovy scripts into a Java application. We'll discuss the GroovyScriptEngine, GroovyClassLoader and GroovyShell and how each works. We'll also cover reloading of Groovy Classes on the fly when they change in order to eliminate the code-compile-deploy cycle.

Attendees should walk away with the ability to embed Groovy into any Java application and understand the differences between the three methods of embedding.

By Brian Pontarelli

Writing APIs is fairly easy but writing an API that is usable and lives longer than a few days is hard. This talk discusses methodologies, tips and tricks for writing good APIs.

During the course of this talk we'll cover many of the common forms of APIs including base types, domains, services and toolkits and how to approach writing each type. We'll also cover the different between internal and external APIs and how to protect your code from your clients.

Attendees should take away a base set of tactics that assist in writing solid APIs.

By Brian Pontarelli

This talk will cover many of the different types of SOA topologies from EJBs and WebServices all the way to message queues and tuple spaces. SOA has many different meanings but it never dictates a single implementation and this talk covers many of the most common implementations of a service oriented architecture.

During the course of this talk we'll cover EJBs, JMS and general message queues, Jini, JavaSpaces, WebServices and ESBs. We'll discuss the pros and cons of each topology and what makes each a better or worse solution for various problems. We'll also cover the fundamentals of network computing and why it is important to understand that SOA is distributed and the impact distribution has on the selection and implementation of the topology of an application.

Attendees should walk away with a more broad understanding of SOA and the numerous ways of implementing this architecture. They should also understand how to go about selecting the correct topology or mix of topologies to meet the needs of their applications.

By Brian Pontarelli

Learn how to create software builds that will stand the test of time and make the world a better place - okay perhaps just your development environment a better place. Builds are usually the tedious work that we all leave to the last minute or sometimes throw together as we build an application. But in most applications, builds contain complex logic and many dependencies, just as the application does. This presentation covers how to make a manageable and enjoyable build system using Apache Ant and a new Ant framework that is part of the JCatapult platform called JCatapult-Ant.

Most companies use the Apache Ant build system either for technical or political reasons. Many developers often wish they could use Maven 1 or 2 because of the plugin structure, dependency management and standardization it provides to applications. Ant sometimes gets a bad rap because it isn't the most simple tool to extend and build files often become large and unmanageable. Plus, Ant extensions are not simple to test and Ant lacks any concept of versioning. Even with all these problems, Ant can still be a great build environment and when used correctly can make creating builds a pleasure.

This presentation covers these topics:

• JCatapult's Ant framework
• Setting up a project
• Adding plugins
• Ant plugins - the what, how and why
• Plugin versioning
• Writing a new plugin
• Using Groovy inside plugins

If you are using Ant for your builds, but want a better solution that includes reusable plugins, dependency management and much more, this presentation will show you how to use JCatapult-Ant to accomplish just that. However, if you aren't able to use JCatapult-Ant, but still want to understand how to create better builds using Apache Ant, this presentation will show you the methodology behind JCatapult-Ant's plugins and allow you to create your own custom plugin system.

Attendees must have a good working knowledge of the Ant build system in order to understand the material in this talk. No other knowledge is required.

By Brian Pontarelli

This presentation covers the latest dependency injection framework named Guice. Guice was written by the developers at Google and makes dependency injection lighter, faster and easier to write. Attendees will learn how to dependency inject their classes using Guice annotations and modules.

Google's Guice is a new light-weight dependency injection framework that uses annotations and Java code rather than traditional XML configuration. Like most of the projects from Google, Guice is extremely fast and reduces latency when constructing new objects and injecting dependencies. Guice supports the most common dependency injection concepts that other frameworks providing, but in a type safe manner and without the XML.

Attendees of this presentation will learn how to setup dependency injection using Guice. This will cover a detailed description of Guice modules, which are Java classes used to configure Guice. It will also cover these topics:

• How Guice uses annotations to inject classes and how to create custom annotations
• How to inject legacy code using Providers
• How to inject different implementations of interfaces using annotations
• Injecting constants
• Injecting statics
• Scopes

Attendees should have a working knowledge of dependency injection.

By Brian Pontarelli

This talk will cover the basics of Struts 2, the latest version of Struts and the marriage of WebWork and Struts 1. We'll be discussing the features of Struts 2 and how developers can get up and running with Struts 2.

Struts 2 is the latest version of Struts that started a port of the WebWork framework into the Apache Struts codebase. From this foundation, Struts 2 has added a number of features not found in WebWork or Struts 1, including a plugin system that already has numerous plugins available and a number of additional features aimed at making Struts extremely extensible.

This talk will cover the following topics:

• Setting up Struts2
• Creating a simple page
• Adding an action and dynamic content to the page
• Adding a form to the page
• Adding validation to the form

Attendees need not know anything about Struts or WebWork to attend this session.

By Brian Pontarelli

This talk focuses on how developers can create Struts 2 applications with little or no configuration using the Struts 2 Convention Plugin. This plugin leverages Struts 2 plugin system and can be dropped into any Struts 2 application. We'll cover how to add the plugin to an application and start coding Struts 2 applications without configuration.

The Struts 2 convention plugin was written to help developers create applications without the burden of the Struts XML configuration files. This plugin uses a package searching method to find actions and standard web conventions to transform those actions into URLs. It also locates the JSPs or other views that correspond to actions and wires everything up without any configuration. However, when the conventions don't work, the plugin provides a number of annotations to allow developers to configure the application without XML.

This talk will cover these topics:

• Adding the plugin to a Struts 2 application
• How actions map to URLs
• Creating an Java package and action class
• Adding the JSP that corresponds to the action class
• Overriding the conventions using annotations

Attendees should have some knowledge of Struts 2 or WebWork and how to develop applications in one or both of these frameworks. Although, those familiar with other MVC frameworks will be able to grasp the concepts with little trouble.

By Brian Pontarelli

JCatapult is a new open source application development platform similar to Spring, Grails and AppFuse. JCatapult provides the ability to create web applications and libraries quickly and also provides a number of features not found in other frameworks. This talk will cover the features of JCatapult and how to get up and start using it.

JCatapult is the next evolution in component based development for Java web applications. Unlike many of the other frameworks available, JCatapult provides the ability to build true components that can be plugged into any application with little or no configuration.

JCatapult is built on top of a number of open source frameworks including Struts 2, Guice, JPA and Hibernate. It provides the glue code that gets all of these frameworks working together and also adds a number of services including email and scaffolding.

This talk will cover these topics:

• JCatapult features
• Making a new web application
• Using Struts 2 conventions to add functionality to the web application
• Adding JPA entities to the web application
• Scaffolding a CRUD operation
• Adding a pre-built component to the web application
• The underlying technologies and how they fit together

Attendees don't not need to know much about all the underlying technologies that make up JCatapult. Rather this presentation provides a method for understanding JCatapult and how it works with all those technologies. Once developers are ready to start using JCatapult, the JCatapult documentation provides a great starting place as well as links to all of the documentation for the underlying frameworks.

By Brian Pontarelli

This talk covers the difficult subject of dependency management and uses the Savant open source framework to illustrate how to tackle some of the more difficult problems of dependency management. During this talk we'll cover the basics of dependency management, software versioning, compatibility, upgrading, and much more.

Dependency management is a difficult problem that all projects must deal with. As projects contain more dependencies and start leveraging tools that providing transitive dependencies, this task becomes even more difficult. There are only a few tools available that providing dependency management including Maven 2, Ivy and Savant. This presentation will use the Savant tool in order to illustrate dependency management and how to manage it.

This talk will cover these topics:

• Dependency management
• Software versioning
• Compatibility
• Savant project files
• Dependency resolution
• Integration builds
• Full releases

If you build software in any form and don't currently use dependency management or sometimes run into issues with dependency management, this talk it for you. It will cover all the basics of dependency management as well as more complex topics such as software compatibility and integration builds.

Attendees don't need to know anything about dependency management or have any knowledge of the tools available in order to attend this session. However, if you do understand dependency management and already use one of the tools, but still have troubles with dependency management, this talk can still provide additional insight into this complex problem.

By Brian Pontarelli

This talk will focus entirely on JCatapult component development. JCatapult is a new web application platform that allows developers the ability to write true components that can be plugged into any JCatapult web application. These components can have entity objects, actions, views, services and much more. During this talk, we'll discuss all the possibilities and create a new component.

JCatapult is a new web application development platform built around the concept of components and pure conventions. Everything inside JCatapult application's is discovered dynamically and requires little or no configuration. This talk will cover everything you need to know in order to start writing JCatapult components.

Here are the topics we will cover:

• JCatapult component architecture
• Creating a new component
• Adding an action
• Adding a view
• Adding a service
• Adding a Guice module
• Adding an entity
• Scaffolding CRUD
• Static resources
• Integrating components into web applications

Although not required, some knowledge knowledge of JCatapult prior to attending this talk is helpful. In order to understand how JCatapult web applications work, attendees should try to attend the JCatapult - components, services and more talk first.

Prerequisite: JCatapult - components, services and more

By Brian Pontarelli

This talk will focus on the JCatapult security framework and how it can be used and extended to provide security in web applications. JCatapult is a new web application platform and one of the features it provides is a security framework that handles most web application security needs. This framework is extensible and defines APIs that allow extremely loose coupling to the framework itself.

JCatapult is a new web application development platform that provides many features, including a security framework. JCatapult is discovery based and the security framework is no exception. This talk will show how JCatapult applications can simply add the security framework to their dependencies, implement the necessary interfaces and quickly add authentication and authorization to the web application.

Here are the topics we will cover:

• JCatapult discovery
• Adding the security framework
• Custom user objects
• Implementing the security interfaces
• Adding a login form
• Configuring authorization
• Saved request handling

Although not required, some knowledge knowledge of JCatapult prior to attending this talk is helpful. In order to understand how JCatapult web applications work, attendees should try to attend the JCatapult - components, services and more talk first.

Prerequisite: JCatapult - components, services and more