By Ted Neward

Security's become a hot topic among enterprise developers in recent years, but to many developers, security is still the white elephant in the middle of the room. Discussions about security usually begin with, "Uh, we'll worry about that later", or, "Start with two really large prime numbers.....". Security isn't as hard as developers make it out to be, but it is something that developers need to face and recognize.

In this talk, we'll extract the 10 Items on Security from Effective Enterprise Java and talk about them, giving developers the basic heads-up they need to have when building enterprise systems in Java.

By Ted Neward

Over the last decade, focus in inter-process communication has centered on Remote Procedure Calls (RPC) and its object-oriented equivalents.

In this session, we discuss the benefits of using another communication approach, messaging, to gain flexibility, scalability, and integration benefits that traditional RPC simply can't provide.

By Mark Richards

As companies continue to change the way they do business, so must the IT systems that support the business. Changes due to regulatory requirements, competitive advantage, mergers, acquisitions, and industry trends require flexible IT systems to meet the demands of the business. Software Architects must therefore make their architectures more agile to meet the flexible demands of today's business. Through real-world examples and scenarios we will explore some of the challenges facing Software Architecture and discuss several concrete techniques for applying agility to both the architecture process and the technical architecture itself. We will also look at various architecture refactoring techniques, and discuss the pros and cons of each. By attending this session you will learn how to apply various agile techniques to improve your architectures and overcome some of the challenges facing software architecture in today's ever-changing market.

Agenda:

- Introduction

- Part One: Applying Agility to Architecture (Interactive)

- Part Two: Agile Methodologies - FDD

- Part Three: Agility and Architectural Refactoring

By Mark Richards

There has been a significant amount of buzz in the community and industry about the definition and role of an Enterprise Service Bus (ESB), particularly within the area of Service-Oriented Architecture (SOA). In this product-agnostic high energy session we will take a step back and consider whether we really need an ESB. Through real-world application and architecture scenarios we will see where an ESB would be helpful and where it would be overkill. We will take a look under the hood and find out just what an ESB is really doing, and take a quick look at JBI (JSR-208) and see the impact it has on the ESB worls. Then, using product-agnostic coding examples we will learn what an Enterprise Service Bus is supposed to do, then answer the question about whether the ESB is just a bunch of hype or if we really need it.

Agenda

- Introduction

- Handling Distributed Services Today

- ESB Alternatives

- Services

- ESB Capabilities

- Rolling Your Own: Possible Java Implementations

- ESB Use Cases

- JBI (JSR-208)

- Summary and Q&A

By Mark Richards

The new EJB 3.0 spec (JSR-220) offers some great improvements over the prior EJB specs in terms of development simplicity and new features. In this session we will take a look at the new EJB 3.0 spec and the new Java Persistence API. Included in this session will be a discussion about Java metadata annotations, simplification of enterprise beans (session and message-driven beans), interceptors, changes in transaction processing, and how the new Java Persistence API works. During the session I will be demonstrating how the EJB 3.0 spec differs from the EJB 2.1 spec through code example comparisons. I will also be discussing how the new Java Persistence API compares to related Java persistence options and whether we should be excited about the new persistence API or (yawn) sticking with what we have.

Agenda

- Introduction

- EJB 3.0 New Features Summary

- Java MetaData Annotations – no more ejb-jar.xml?

- Constructing and accessing an EJB 3.0 Session Bean

- EJB 3.0 Transactions

- Interceptors and use of the @AroundInvoke annotation

- Entities and the Java Persistence API

By Mark Richards

Tired of dealing with EJBs but cannot use other frameworks like Spring? How would you like to replace all of your remote Stateless Session Beans with POJOs and still access them remotely within Java EE? By using the Java EE Command Pattern we can write EJBs as POJOs and solve many of the issues facing EJB, including testability, configuration complexity, and performance, and still remain within the boundaries of the Java EE container. The Java EE Command Pattern is a simple pattern that can significantly reduce the complexity of large-scale Java EE enterprise applications. In this session we will explore the numerous issues facing a typical EJB architecture and learn how the use of the Java EE Command Pattern can solve these issues. We will walk through the different design alternatives and see how the command pattern is implemented in both EJB3 and in Spring. Through interactive coding examples you will learn what components make up the Command Pattern framework and what simple coding changes are required to convert a complex remote EJB-based application to a much simpler remote POJO-based application.

Agenda

- Issues with J2EE

- Java EE Command Pattern Introduction

- Java EE Command Pattern Core Components

- The Command Pattern Framework Implementation (EJB)

- The Command Pattern Framework Implementation (Spring/RMI)

- Applying the Command Pattern to a Typical EJB Application

By Mark Richards

Although Spring and EJB isolate us from most of the complexities involving transaction management, there are still a number of things we need to be aware of when dealing with transactions in Enterprise Java Applications. Too often transaction management is an afterthought in the design and development process, which leads to applications that have problems with data integrity, data consistency, and overall stability and reliability. In this session we will explore the three transaction models that both Spring and EJB support (Local, Programmatic, and Declarative), and discuss the advantages, disadvantages, and pitfalls within each of these models, when it makes sense to use each transaction model, and under what situations these models are appropriate and inappropriate. We will spend most of our time on the Declarative Transaction Model. Within this model we will explore some common pitfalls and look at the best practices within this model. Through coding examples in both EJB and Spring using real-world scenarios, you will learn how to properly handle exceptions, how to correctly use transaction attributes, and how the isolation level can affect transaction and application behavior. This session is the first part of a 3 hour transaction management session.

Agenda:

- Introduction

- Local Transaction Model

- Programmatic Transaction Model

- Declarative Transaction Model

- Best Practices and Pitfalls

By Mark Richards

This session is the second part of a 3 hour transaction management session. In this session we will explore some of the more advanced features of transaction management within EJB and Spring. We will pick up where we left off from the first session by taking a detailed look at XA and distributed transaction processing, and how to coordinate multiple resources within a single business transaction. Within the XA discussion you will learn what XA is, what the relationship is between JTA and XA, when you should use XA within EJB and Spring applications, and how to enable JMS and DBMS resources to run under XA. In the second part of this session we will look at how to build an effective transaction design strategy by reviewing three primary transaction design patterns. Within each pattern we will look at the context, forces, solution, and the pattern implementation in both EJB and Spring. We will also see how each transaction pattern fits into variousl application architectures.

Agenda:

- What is XA?

- What is the relationship between XA and JTA?

- When is XA required?

- When should we use XA Drivers?

- Client Owner Transaction Design Pattern

- Domain Service Owner Transaction Design Pattern

- Server Delegate Owner Transaction Design Pattern

- Applying Transaction Design Patterns (Spring and EJB)

By Brian Sletten

Service-oriented architectures (SOAs) are all the rage. But how do you find all of these services once they are deployed? Configuration files are so 90's. Software of the 21st Century should be able to find related services and components without users having to specify particular configurations at start up. The IETF's ZeroConf multicast DNS protocol was designed to solve exactly this problem. JmDNS is Java-based open source implementation of this capability that allows local-link applications to find and use automagically discovered capabilities. Apple's Rendezvous technology is another open-source ZeroConf implementation behind many of the exciting applications it is building for OS X these days. Come learn how you can interact with these or your own service discovery-savvy applications without even having to learn how to spell UDDI. Bring your wireless notebooks to participate in a service-oriented environment (please have a working Java environment as we won't have time to debug installation issues).

Attendees will learn

- Why you don't need UDDI to find services

- The basics of multicast DNS and the ZeroConf protocol

- How to take advantage of Bonjour-enabled devices and software

- How to build their own applications that can be found without a central repository

Rating: Advanced

Category: Client or Server-side Java

Prerequisites: Basic to Intermediate Java skills, basic networking knowledge

By Brian Sletten

Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al inform us that what we have seen so far is just the beginning. His original plans at CERN were larger and grander. The Semantic Web is the new vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. While there are many naysayers chiding such grand visions, there are also pragmatic and useful technologies emerging that can be applied today.

Attendees will learn:

The history and motivations behind the Semantic Web

The technology stack that will make it happen (including RDF and OWL)

An overview of tools and technologies that are beginning to satisfy the vision

This talk stands on its own, but feeds into the "Experiencing the Semantic Web" talk which is more hands on.

Rating: Intermediate

Prerequisites: This is all so new, most engineers will find something to excite them.

By Venkat Subramaniam

A number of new features have been introduced in Java. What benefit do these features offer you. Are there issues with using these features. For instance, when should you use annotation? The objective of this presentation is not simply to introduce you to the features, but to the effective use of these as well.

We will take a close look at a number of features that you will be expected to know well when you program using Java 5.

By Venkat Subramaniam

Agile development is picking up steam. You have heard about eXtreme Programming(XP). What other Agile methodologies are you familar with and what do they bring of interest or significant to the table of Agility? More important, why should you learn about these different methodologies instead of simply focusing on one? There is no one shoe that fits all. Any methodology that requires you to follow it in totality and not let you adapt is rather dogmatic, not pragmatic. To be effective we have to take the best of different approaches and apply to our projects base on our specific needs.

In this session, we will look at different methodologies (XP, Scrum, FDD, Crystal, ...) that promote agility. We then will compare and contrast the features of each. You can take away from the presentation what makes the most sense for your project and team.

By Venkat Subramaniam

You are convinced that Test Driven Development is good for you and your project. You realize the benefits it has to offer. What's holding you back? All the code and components that your code so heavily depends on is most likely making you wonder if TDD is really for you. We will start out by looking at dependency and dependency inversion. Then we will discuss how mock objects can help separate our code from its dependencies.

In this presentation, we will take an examples oriented approach to utilizing mock objects. We will first hand toss a mock and see how our code benefits from it. Then we will take a look at using frameworks that can assist with the creation of mocks.

By Venkat Subramaniam

Java introduced Generics in the 1.5 version (Java 5). What are the capabilities of Generics? How do you use it? Are there some gotchas in using it? In this example driven presentation, we will start at the basics of generics and look at its capabilities. We will then look at some of the under the hood details on generics implementation. We will then delve into the details of some of the changes to Java libraries to accommodate generics. Finally we will take a look at some restrictions and pitfalls that we need to be familiar with when it comes to practical and prudent use of generics.

Topics:

• Need for Generics

• Generics in Java

• Bounded Parameters

• Wildcard

• Restrictions

• Generics Implementation

• Effect of Erasure

• Java libraries changes

• Pitfalls and pragmatics

Benefits:

• Know your generics

• See how to create your own generics

• Understand issues with converting to genetics

• Learn the limitations

• Attain the wisdom

• Decide if this if for your project

By Venkat Subramaniam

Object-oriented scripting languages, or agile dynamic languages, as some like to call those, are gaining programmers' attention. Groovy bring this excitement to the Java platform with its ability to generate byte code. You can use Groovy instead of Java for some parts of your application. By learning it, you can switch between the languages where you consider fit.

In this session we will learn what Groovy is. We will take an example driven approach to look at interesting features. We will see how a piece of code you would write in Java can be written, elegantly, using Groovy. In addition to the current features, we will also discuss the state of the language and tools.

By Venkat Subramaniam

Is your code object-oriented? Developing with objects involves more than using languages like Java, C#, C++ or Smalltalk for that matter. From time to time, the OO paradigm stumps even expert developers. Agile programming becomes a mere act of hack if we code without knowing the OO principles. What are these principles – the ones that influence your design? In this presentation the speaker will present some of the challenges that are fundamental in nature. Then he will present OO Design principles and good practices for prudent development of OO code.

Topics:

• Metrics of design

• Good design vs. bad design

• Perils of design

• Principles for OO Design

• Examples that illustrate the principles

Benefits:

• Learn principles that lead to better design

• Learn fundamentals that will change the way you will code

• Gain insight into the design tools needed for agile development

• Helps improve the quality of your system

• Better your design skills

By Scott Davis

Hopefully your test plan involves more than, "Well, it compiled..." JUnit is fast becoming a required part of the modern Java developer's toolkit. Unit testing your Java classes is a great start, but your test plan shouldn't stop there.

This talk will introduce several additional testing tools for the web developer -- HttpUnit, Canoo WebTest, and JMeter. These tools allow you to test a live website with no changes to the production code. Even better, you can test sites that have been implemented in technologies other than Java.

You will see code examples and live demos of these tools in action. We'll talk about the differences between unit testing, functional testing, and performance/load testing. Come get "test infected" -- you'll never look at the development process the same way.

By Scott Davis

Frameworks? We don't need no stinkin' web frameworks. OK, so maybe that's overstating the case. Web frameworks do plenty of good things, but sometimes they can also be golden handcuffs. Too many web developers fall into the trap of thinking, "If it can't be done by my web framework, then it simply can't be done."

This presentation focuses on the cool things that you can accomplish by stepping out of your web framework and getting closer to the underlying technology. We'll take a detailed look at what really goes on during the request/response cycle, and how new techniques like AJAX allow you to break the mold. We'll look at the clever things you can do with MIME types, User-Agents, and HTTP Headers in general.

Old technologies like CSS, DOM, and JavaScript are experiencing a renaissance under the guise of new names like DHTML and AJAX. Google Maps and GMail are literally redefining our expectations of how rich a web application can be by using these technologies to their fullest potential. Co

By Scott Davis

In this presentation, we'll explore the top four mapping sites and show you how to take advantage of their free services. MapQuest, Yahoo Maps, Google Maps, and MSN Virtual Earth all bring slightly different capabilities to the table. These sites allow you to create your own interactive maps with minimum effort and no previous mapping experience. They take care of hosting the mapping data and making it easy to manipulate -- all you have to do is bring a little bit of know-how to the party.

Thanks largely to Google, web mapping is experiencing a renaissance. Google's mission statement is, "... to organize the world's information and make it universally accessible and useful". They aren't specifically talking about web mapping, but the sentiment certainly applies. If you have data that naturally has a geographic element (a customer list with addresses, sales reports by regions, even a collection of favorite restaurants), today's websites make it easier than ever to display them on a map.

Even if you aren't specifically interested in creating your own maps, this presentation gives real-world examples of many industry hot-button topics -- SOAP vs. RESTful web services, JavaScript

By Scott Davis

The full title of this talk is, "The Sound of One Hand Clapping, or How to Pair Program with a Single Programmer -- Scaling XP to Small Projects." Everyone talks about using J2EE for massive projects, but what about the lone wolf developer? Can they still apply the lessons learned from agile development methodologies to their everyday work?

XP is an ideal methodology for dealing with small business owners and entrepreneurs. Often times small projects suffer from the complete lack of good programming practices because heavy-weight methodologies don't scale down well. Heavy-weight methodologies can also be intimidating to the non-computer professional. XP scales well to small projects and allows the domain experts to participate in good programming practices (sometimes for the very first time).

By Keith Donald

In this interactive session Keith walks you through the experience of building a simple Spring-powered application from the ground up.

You will learn how to use Spring to assemble an application system from a set of focused, loosely-coupled components. You'll see how Spring enables agile development by allowing you to start simple, validate architectural choices early, and scale up infrastructure as requirements demand.

Expect live coding with a supporting business case. This "big picture" session focuses on teaching how to get the most mileage out of the Spring Framework as you can.

By Keith Donald

Spring 1.2 is out--Spring 1.3 is right on the horizon. As a broad, user-driven project with a large community, the newest releases offer a wealth of new features to be taken advantage of. This session focuses on demonstrating the most important, and how you can start leveraging them in your projects immediately.

You'll learn how to use Spring's JMX support to add manageability to your apps. You'll see how to use Spring Web Flow to create robust web applications atop business process workflows. You'll learn about Spring Security (Acegi), Hibernate 3 integration, JDK 1.5 transactional annotations, and the latest core container and utility enhancements.

By Paul Duvall

Increase feedback on your project by building your software with every change applied to your source code repository. The practice of Continuous Integration (CI) can be used to decrease the time between when a defect is introduced and when it is fixed.

You will learn how to get the CruiseControl CI server and a source code management repository to work together in a CI system. From a working reference implementation in Java, you will learn the attributes that make up an effective development platform for CI. Learn how to use the CI system as the centerpiece to your software development activities to create automated code reviews, generate diagrams and documentation, and detect anomalies on a continual basis. Paul will use CruiseControl, Subversion, Ant, JUnit, and other tools that can help you implement a powerful CI system.

By Paul Duvall

Design Patterns became part of the software development industry mainstream in the mid-1990s with the release of the Go4 Design Patterns book. Since then, architecture, design, and more recently, organizational patterns have become a part of our nomenclature. But, what about the software that helps us develop and deliver the software to our users: the software development infrastructure?

Paul will introduce you to patterns such as the Robot, Detector, Kitchen Sink, and Scorched Earth patterns that will help you build a robust software development infrastructure. The implementation of these patterns will help reduce common risks on your projects and allow you to focus on the interesting work of solving the unique problems of your users.

By Ben Galbraith

Too often, Swing applications are slow, ugly, and hard-to-maintain. It turns out that it doesn't have to be this way. Swing can be used to create highly-responsive, beautiful applications that are very maintainable. If this isn't consistent with your own experience, don't feel bad; its not very obvious how to make Swing sing.

In this session, I explore three topics that lead to much better Swing applications:

Proper Swing threading

High-quality third-party Swing look-and-feels

Good practices for coding Swing applications

In the threading portion of the session, I explain Swing's event handling architecture and its implications for Swing applications. Understanding this topic is crucial to creating highly-responsive Swing apps. I demonstrate how to use this knowledge in the form of many live-coded examples, and I show how frameworks like SwingWorker and FoxTrot can make this easier. Java's default look-and-feel, Metal, is awful (and in my opinion, the "Ocean" theme in JDK 5.0 doesn't do enough to improve it

By Ben Galbraith

It sounded like such a good idea back in the mid-nineties: based the Java platform on a standards-based, open community, and let anyone participate. There is no question that Sun's strategy for Java's stewardship via the JCP and sponsored open-source has yielded some enormous benefits. However, these have not been enjoyed without tremendous cost.

Perhaps the recent pop-culture book The Paradox of Choice put it best: "When people have no choice, life is almost unbearable. As the number of available choices increases, [as it has in the Java community], the autonomy, control, and liberation this variety brings are powerful and positive. But as the number of choices keeps growing, negative aspects of having a multitude of options begin to appear. as the number of choices grows further, the negatives escalate until we become overloaded. At this point, choice no longer liberates, but debilitates. It might even be said to tyrannize."

Does this ring true in your environment? Are you tired of spending countless hours evaluating IDEs, build s

By Ben Galbraith

For many of us, XML has become a ubiquitous presence in application development, whether parsing, validating, or manipulating it. For many of us, all that XML is coupled with pain, in the form of tedious APIs (like, say, the W3C DOM API) and confusing technologies (oh, I don't know, W3C XML Schema?).

In this session, I share the following tips for making the XML in our lives a little easier to deal with:

- Use StAX instead of SAX

- Use StAX to create XML

- Use JDOM instead of W3C DOM

- Use XPath to select XML

- Use Jaxen to enable XPath over custom trees

- Use RELAX NG instead of DTD or WXS

- Use Trang when DTD/WXS output is required

- Use Sun's RELAX NG Converter when WXS input is required

- Consider RELAX NG's compact syntax

- Use Schematron to extend schema languages

- Consider XML namespaces for versioning

- Ignore unknown namespaces

By Ben Galbraith

Ajax -- called DHTML just a few months ago -- has revolutionized (or "radically iterated", if you like) web application development in the short few months since the term was coined.

What is it all about? Why are we excited about a set of capabilites that have been sitting in our browser for years? What can you do with it? And, how can you do it?

Ajax, short for Asynchronous JavaScript and XML, is a technique for communicating with servers from within a web page without causing a page refresh.

This session provides an introduction to Ajax and an orientation to the state of the ajaxian universe. The basic ajaxian techniques will be demonstrated through live coding, and more advanced examples of Ajax will be demonstrated and deconstructed.

Attendees will understand how the Google Maps UI is built (and why it isn't as hard as it looks), how Ajax can improve portals, community sites, and pretty much any other type of web application.

Furthermore, the issues surrounding how to create an Ajax application that doesn't turn into an unmain

By Ben Galbraith

In the "Introduction to Ajax" session, we discuss what Ajax is, how it works, and how others are using it.

This session goes deeper into Ajax by reviewing the existing JavaScript frameworks that aim to make it easier.

The scope of the frameworks is all over the made, from unit testing JavaScript to deconstructing other websites to making it easier to create your own ajaxian effects.

If you want to easily add some Ajax to your site, come to this talk, presented by one or more of the founders of Ajaxian.com.

By Ben Galbraith

Are you spending more time plumbing your Swing applications than solving business problems? Has your Swing application grown out of control? This session is for you.

In the first part of the presentation, I analyze the architectural problems that plague many Swing applications and present architectures that overcome these problems. These architectures are presented in terms of principles along with a reference implementation. You can therefore either adapt the principles to meet the needs of your existing applications, or incorporate the specific ideas of the reference implementation into your new projects. Fortunately, there are some existing frameworks that have done some of the architectural work already. I present some of these frameworks in the rest of the presentation.

By Ben Galbraith

You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years, XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally interesting. Things get really exciting when XML is dynamically transformed into other formats. In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML -- a sort of open-source version of the popular Macromedia Flash format. SVG files can be converted into beautiful, completely scalable -- and interactive - - images.

You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years,

XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally

interesting. Things get really exciting when XML is dynamically transformed into other formats.

In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a

typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML --

a sort of open-source

By David Geary

Okay, so you know a little about JSF. You understand managed beans, action outcomes and how to attach standard JSF validators to components in a JSP page.

But there is a great deal of functionality that the average web application supports that JSF doesn't provide out of the box. For example, wouldn't you like to have JSF automatically place asteriks in front of labels for required fields? You are going to implement client-side validation, which JSF does not support out of the box, aren't you? Of course, you're going to test your application, right? And don't forget to trap unauthorized use of the back button.

How do you do all of that stuff in a JSF application? If those are the kinds of questions that keep you up at night, then this session is for you. We will explore the outer reaches of JSF development to illustrate how you can bend your next JSF application to your will.

By David Geary

JavaServer Faces is a well designed user interface framework, but it lacks a number of features you might otherwise expect out of the box; for example, JSF does not explicitly provide support for client-side validation.

So, from the folks that brought you Struts, comes Shale, a collection of useful enhancements to JSF. A top-level Apache Software Foundation project, Shale adds some really cool features to vanilla JSF, including:

Web flow: script dialog flow Remote Method Calls: easily call JavaBean methods from JavaScript Tapestry-like views: code views in pure HTML Use Apache Commons Validator validators on the client or server, or both JSF testing framework: mocks for easy JSF testing

There's a lot of cool stuff in Shale that makes JSF a much more compelling proposition. Come see what it's all about.

This is a code-intensive, fast-paced look at Apache Shale. Forty-plus slides and five demos makes for an action packed session that illustrates the cool features that Shale provides.

By Andrew Glover

Understanding what code coverage represents, how to effectively apply it, and how to avoid its pitfalls will give you an unprecedented understanding of how unit tests may or may not be covering you from sneaky defects.

You’ve drunk the XP cool-aide and made a concerted effort to actively unit test your code. After awhile, however, you may find yourself wondering how good are those tests? Are they actually covering the code adequately? Understanding what code coverage represents, how to effectively apply it, and how to avoid its pitfalls will give you an unprecedented understanding of how those unit tests may or may not be covering you from sneaky defects. We’ll talk code based coverage and specification-based coverage and we’ll look at the tools available to gather these metrics in both the open-source and commercial worlds. Additionally, we’ll examine the notion of mutation testing and its affect on code

By Andrew Glover

No one will argue that JUnit has positively affected the quality of thousands of Java applications around the world. JUnit’s simplicity and ease of use ushered in a whole new era of code quality; however, as many developers have found, its simplicity has also limited its use. TestNG was designed from the ground up to overcome some of JUnit’s limitations; moreover, TestNG’s features make it a great tool to complement your JUnit tests.

In this session we’ll learn about TestNG’s flexible fixture model, its test categorization capability, dependent methods, and TestNG’s powerful parametric testing facility. We’ll also see how both TestNG and JUnit can play together in a build process.

By Stuart Halloway

Ruby may not need XML, but XML sure benefits from Ruby!

In this talk we'll tour XML processing in Ruby:

REXML

Builder (used by Rails to emit XML)

Stream parsing

Pull parsing

Tree parsing

XPath

We'll conclude by metaprogramming Ruby to generate Ruby objects from XML domain vocabularies. Ruby's dynamic features make XML data binding a snap.

By Stuart Halloway

Have fun automating your builds and deployment!

Ruby rake has everything you need to automate your builds: In this talk we'll look at Rake's take on common build metaphors:

Dependencies

Tasks

File management

Automated tests

Generating documentation

Then, we'll drill into what makes Rake special: Because Rake is a

domain-specific language (DSL) built from Ruby, you have all the power

of Ruby at your fingertips. This is a vast improvement over custom

syntax (e.g. makefile) or tedious XML (Ant).

We'll look at a series of examples from a Rails application rakefile

that demonstrate how Ruby code mixes seamlessly with Rake syntax to

produce clean, simple, beautiful builds.

We'll conclude by looking at RubyGems, which is the de facto

packa

By Stuart Halloway

Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.

Java's support for threads is broad and deep. From the early days of the platform, programmers have used threads, synchronized blocks, and monitors to build safe multi-threaded applications. Java 1.5's new concurrency utilities greatly reduce the need to use these primitives directly. Now, Java provides a set of lock classes and task scheduling tools that provide much more leverage in writing real applications. We'll explore java.util.concurrent, and also see how the Java Memory Model has been corrected in 1.5.

Most of the advantages of java.util.concurrent can also be had in previous version of Java. We'll discuss Doug Lea's concurrency utilities and the backport of java.util.concurrent to

By Stuart Halloway

Using the Action WebService pack that ships with Rails, you can rapidly create robust web services with the same productivity you see when developing classic web applications with Rails.

The integration of ActiveRecord as an ORM framework, plus Builders for rapidly generating XML documents, provides for rapid deployment of standard services. Add on Ruby's powerful metaprogramming strategies, and you can quickly and easily build a library of filters and interceptors to provide services like encryption, digital signatures, routing, etc. that enable your business rules.

By Stuart Halloway

For centuries people have used crypto to build (and break) secure systems. Computers have only raised the pitch of conflict, providing enormous cryptographic power at commodity prices. Most programmers do not write their own crypto libraries, instead relying on the services of an operating system or virtual machine. But even with all this support, building secure systems is a daunting task.

This talk will cover three things all programmers need to know:

1. the basic tools of computer crypto

2. the programmatic APIs to these tools

3. common programming mistakes that can undermine otherwise secure systems

You will learn the basics of hashing, message digests, public key encryption, symmetric key encryption, certificates, and key management. With each, you will see programmatic examples, with advice for correct usage.

By Stuart Halloway

The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

You will learn the core APIs:

SecurityManager, AccessController, Permissions and Policy

JAAS Subjects, Principals, and LoginModules

You will then see how to invoke these APIs in real application scenarios. You will learn how to:

Partition your applications to safely invoke downloaded code

Read and write Java policy files

Extend the architecture with custom permissions

Provide secure services through PrivilegedActions

Use JAAS to authenticate and authorize users

By Ramnivas Laddad

J2EE has become the main new platform for enterprise application deployment. Good performance is an important business requirement. Supporting this requirement needs application profiling during the development phases and performance monitoring after application deployment. Come to this session to understand challenges and choices in monitoring J2EE applications.

Performance monitoring solutions must work under constraints imposed by the environment. Further, they must balance conflicting requirements such as overhead vs. richness of information. All of these need careful understanding of both requirements and solutions as well as the costs of any tradeoff decisions.

This session presents various tools and techniques available for monitoring J2EE applications. We will consider requirements of performance monitoring solutions in different scenarios. We will also discuss underlying enabling technologies such as Java Virtual Machine Profiling Interface (JVMPI), Java Virtual Machine Tool Interface (JVMTI), JFluid, JMX, design patterns, and aspect-orien

By Ramnivas Laddad

Aspect Oriented Programming (AOP) enables modularizing implementation of crosscutting concerns that abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concerns in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to system requirement changes. Come to this session and learn all about how AOP can help you simplify developing complex systems.

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with the most commonly used IDEs, which makes the Java developer more productive.

This session is targeted at the developer with no or little familiarity with AOP and AspectJ. It will introduce AOP’s concepts and the AspectJ programming language, along with many examples and live coding to solidify the concepts learned. After attending the session, you will have a clear idea about AOP's value and

By Ramnivas Laddad

Aspect Oriented Programming (AOP) enables modularizing implementation of crosscutting concerns that abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concerns in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to system requirement changes. Come to this session and learn all about how AOP can help you simplify developing complex systems.

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with the most commonly used IDEs, which makes the Java developer more productive.

This session is targeted at the developer with no or little familiarity with AOP and AspectJ. It will introduce AOP’s concepts and the AspectJ programming language, along with many examples and live coding to solidify the concepts learned. After attending the session, you will have a clear idea about AOP's value and

By Ramnivas Laddad

A lot is happening in the field of Aspect-oriented programming (AOP). AspectJ and AspectWerkz, the two leading AOP implementations, have merged, bringing in their respective strengths. The merged version, AspectJ 5, adds many new features aimed at simplifying writing and deploying aspects. The new features include an annotation-based and XML-based syntax to define aspects, support for new Java 5 concepts, and load-time weaving. The tools support for AOP continues to improve, as well. Further, the most popular IOC framework, Spring, enables integrating aspects written in AspectJ. There is also serious discussion and preliminary work going on to support AOP right into the VM itself. All in all, there is a lot to learn about the changes in the exciting field of AOP. This session is designed to help you get up to date with all these changes.

This session provides a guided tour of the new things in the AOP world. It explains new features in AspectJ along with the practical considerations in utilizing each of them. The presentation explores the fundamental synergy between AOP and metadata to understand right (and wrong) utilization of metadata-based crosscutting. Load-time weaving (LTW) enables adding aspects to your existing applications deployed in any application server with a minimal effort. The presentation shows how to utilize LTW to improve your productivity considerably, even if you don't yet subscribe to the AOP philosophy and don't want to use AOP in production. The presentation also demos the latest AspectJ Development

By Ramnivas Laddad

Aspect-oriented programming (AOP) promises to modularize crosscutting concerns. Like all new technologies, AOP has its share of over zealousness and unjustified criticism, neither of which is useful to developers deciding if they should use AOP in their applications. Attend this talk to understand the real deal behind AOP and change your perspective of AOP forever.

This talk goes beyond myths surrounding AOP and shows the real deal. It examines many practical applications implemented with and without aspects, providing a context for scrutinizing AOP. It also discusses ways to adopt AOP in pragmatic, risk-managed ways allowing developers to try AOP in their own system and gain understanding at the experiential level without exposing them to undue risk.

This session is aimed at developers who have some understanding of AOP, perhaps even considering using it in their system, but have some lingering concerns about its practicality. After attending the session, you will have a clear picture of AOP and be ready to make a studied decision about it.

By Jared Richardson

a.. Do you spend more time fighting your tools than writing code? b.. Do you avoid merging your code with your teammates because of “Integration Hell”? c.. Do the same bugs keep sneaking back into your product? d.. Do your builds depend on the roll of the dice?

A good set of infrastructure tools can go a long way toward smoothing out these and other problems. Come see how to make your toolset work seamlessly in the background so you can Just Work. We'll cover source code management (SCM), build scripts, automated test harnesses, automatic builds, feature tracking and issue tracking.

As part of the session, we'll set up Subversion, create a project, and then add code for the SCM section ... just to obliterate the "it takes too much time to set up and use" argument. For build scripts, we'll add an Ant script. Let's throw in a few JUnits to demonstrate test automation, and then I'll put it all together in CruiseControl. The live demo will include breaking the build, then breaking the JUnit test, and then finally fixing it and seeing it all work.

For this first session, we'll look at Subversion, Ant, and start the Cruise Control discussion.

By Jared Richardson

Are your product designs hit or miss? Do you have trouble building a loosely coupled system? Is your code incestuous? Refactoring not an option with your code base? Tracer Bullets help keep your project out of the fire.

Tracer Bullet Development:

* helps you create great software
* lends itself to an iterative cycle
* can be used for demos early and often
* is easily refactored
* allows your teams to work in parallel
* makes a very testable system

Tracer Bullets can coexist with nearly any other development methodology. Come see how easy it is!

By Jared Richardson

Throughout our software careers we learn habits from our coworkers, from books we've read, and occasionally, from conferences we attend. Much of our competence comes from the tips and tricks we pick up as we go.

In this session, learn five of the techniques I've borrowed along the way. We'll discuss The List, code reviews, code change notifications, daily meetings, and tech leads. These techniques are often abused, but when used properly they can make a huge difference in how you develop software. Take this opportunity to add these practices to your toolkit.

By Ryan Shriver

Scaling Agility is a case study in leveraging Agile practices for larger-scale software product development.

The session will cover 7 major areas:

Case Study Background - Brief history and project context for the case study

Getting Started - Introducing Agility into the team

Current Agile Approach - How our processes have evolved over time as the teams have grown

Tools & Techniques - Things that have helped us along the way

Lessons Learned - Feedback from implementing Agility

Best Practices - Gleaned pearls of wisdom

Recommendations - Things you may want to consider on your Agile project

By Bruce Tate

Agile programming is a collection of core principles and techniques that allow software developers to create lighter, more responsive applications, and to have fun doing it. Many established organizations are either openly or sub-conciously hostile to many of the principles of Agile development.

We'll explore the intersection of these new practices and old-world sensibilities, relying on real-world case studies to illustrate some of the compromises that are necessary to bridge the gap. In addition to technical and process aspects, we'll also spend some time talking about the business aspects, such as how Agile development affects contracts.

By Bruce Tate

This session, for the Spring beginner, helps you: • Understand dependency injection and inversion of control • Know the meaning of lightweight containers and Spring • Understand the basic pieces of Spring • See core Spring modules in action, including Persistence, AOP, transactions.

Attendees need not know anything about Spring. This session does talk about integration with core J2EE frameworks like JDBC and transactions.

The Spring framework is one of the fastest growing open source frameworks. New job postings are gaining rapidly, and many customers are adopting Spring instead of heavier alternatives. In this session, we’ll introduce Spring. You’ll see how Spring can give you much of the power of EJB, without the complexity or pain.

Spring uses concepts like dependency injection and aspect oriented programming to ease standard enterprise development. Spring developers write plain, ordinary Java objects (POJOs), instead of sophisticated components. In this session, you’ll see a basic Spring application. You’ll also see some details about some of the enterprise integration strategies, including:

• Spring

By Bruce Tate

O/RM (Object/Relational Mapping) seeks to eliminate repetitive or tedious work enabling the CRUD (create, read, update, delete) that underlies most applications. Hibernate is a popular, open-source O/RM tool that uses reflection (instead of code generation, like EJB, or bytecode injection, like JDO) to manage your persistence layer.

This session will introduce you to Hibernate. After an overview of common usage scenarios, including web and enterprise applications, we'll examine the basics of getting Hibernate running. We'll cover the mapping file format and syntax, including common relational mapping structures. Then, we'll examine the Hibernate API for interacting with the framework. Finally, we'll cover the common architectural decisions you'll have to make as you include this (or any other) O/RM framework.

By Dave Thomas

Ruby recently enjoyed its tenth birthday. Instead of cake and candles, the community celebrated by releasing a wave of new libraries and frameworks that make Ruby programming even easier. This talk features some of the best of these, as we explore Ruby.

We'll spend about half the session getting to know Ruby: the syntax, type system, blocks, iterators, and so on. Then we'll dive in and develop some real-world code using web services, RSS, and databases. If you want to come to the Rails talk, and you're not that familiar with Ruby, this talk is a good starting point.

By Dave Thomas

The Ruby on Rails framework has exploded onto the scene over the last few months. Propelled by some genuine benefits, and fueled by a whole lot of controversy, Rails seems here to stay. So, is it a Java killer? (No.) Is it a great way to develop certain classes of web application? (Yes.) Does it really deliver the 10-fold increase in developer productivity that some have claimed? (It depends...)

If you can't help thinking that there must be an easier way of developing web projects, come and join us as we construct an MVC-based Ruby on Rails application using the very latest libraries and tools. You'll get a taste of Ruby, and also a feel for some of the power and productivity gains offered by this remarkable framework. You'll need a grounding in Ruby to get the most from this talk; if you're not already a Ruby developer you might want to attend the Facets of Ruby talk before coming to this one.

By Dave Thomas

The Ruby on Rails framework has unit and functional testing baked right in. In this talk we'll see how easy it is to get started with testing in Rails, and we'll explore jut how deep the testing support goes.

We'll look at the basics: unit testing models and functional testing views and controllers. But we'll dig deeper, looking at the supplied mock objects and seeing how easy it is to add our own. We'll also investigate test fixtures, using them to generate both static and dnamic test data. Finally, we'll have a quick look at performance testing.

By Dave Thomas

Are you frustrated by experts who can't tell you what to do, or by junior team members who refuse to see the big picture? How can you best develop careers: both yours and those of your teammates and managers? How can we learn to apply experience more effectively, and why do the many approaches designed to tame complexity actually end up increasing it?

Dave Thomas, of The Pragmatic Programmers, describes the solutions to these and other problems as he turns the Pragmatic Spotlight (and a good dose of twisted humor) on formal learning models, the Nursing profession, and streamlining sheep.

By Dave Thomas

Ajax is becoming a requirement for new applications: it creates richer user experiences and more dynamic applications. However, doing Ajax by hand is difficult and error prone. The good news is that if you use Rails, you don't have to do Ajax the hard way.

Rails has built in helpers that support Ajax development,

and comes packaged with the powerful prototype.js and script.aculo.us

libraries.

Come see how Ajax can be made to work with your Rails applications as

we built a very dynamic ToDo list, and see how Ajax can be made robust

with a simple calculator.