Session Descriptions

Clean scalable builds with Maven

Our build systems have migrated from make to Ant. While Ant does a good job in many ways, is it the right tool for the job? This session talks about taking builds to the next level, looking at tools such as Maven to make your life easier.

Enterprise AOP

Aspect-oriented programming (AOP) has become a hot topic for enterprise development, with recent news of support by IBM, JBoss, BEA, Oracle, Eclipse, and IntelliJ.

Behind the news headlines, however, are critical questions: How real is AOP for the enterprise? What problems can it solve today? How does it apply to enterprise applications? How can one make an informed decision about trying to use AOP? What is the best adoption strategy? What are the long term possibilities for AOP in the enterprise?

This sessions tries to tackle those questions.

Give the DB a break!: Performance and Scalability

What do we really mean by "performance" and "scalability"? This talk gets into the meat of problems which cause our applications to degrade. We will focus on issues such as problems caused by the database being a bottleneck for our application, and see how we can architect our solutions to bypass the issues, resulting in a solid system which scales with the increased load.

Not only will we look at the factors, but I will delve into a couple of case studies to show how real world problems were solved!

How to be Groovy

What? Another programming language? Are you kidding me? That is what we often feel when something new comes around, and is something you may be feeling about Groovy. However, Groovy could fit a niche for you in your daily toil. It is the swiss army nice that Perl/Ruby are, yet lets you work in a more structured way, and plays nice with the millions of lines of code already written on top of the Java Virtual Machine.

Rules Engines

Rules engines are powerful beasts which allow you to program in a way in which you specific rules and facts, rather than a linear set of instructions.

Learn about how you can use Rules Engines in Java development to take care of complicated problems.

Software Metrics and the Great Pyramid of Giza

Most software engineers hate metrics... Why? Because we know the work we do is hard to quantify – any measurement of 'software engineering' is like trying to tell how tall someone is by how much they weigh... There may be some correlation, but there is so much deviation as to make the answer practically meaningless. As a result, we often see metrics used to justify improper conclusions. There are plenty of good metrics though, and plenty of ways to use them effectively.

Understanding and Implementing Pluggable Application Architectures

Pluggable application architectures are everywhere. Applications like Photoshop, Eclipse and other IDEs, and even application servers are all examples of applications that allow other developers to 'install' new functionality. There are plenty of reasons for wanting to install new functionality into an application that is already developed and deployed... from dynamic upgrading to the creation of a 'component marketplace', where end users can purchase components with 'extra' capability.

Advanced Spring: What's New and What You Might Not Know About

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.

The Spring Experience in 90 minutes

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

Continuous Integration

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.

Development Infrastructure Patterns

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?

Advanced Enterprise Debugging Techniques

This session discusses techniques and tools for debugging enterprise applications (without using System.out.println()!)

Language-oriented Programming and Language Workbenches: Building Domain Languages atop Java

This session shows how to use Java as the building block for domain-specific languages. It discusses the next revolution in programming: language-oriented programming and the nascent tools that support it.

Regular Expressions in Java

Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.

Web Application Security Vulnerabilities

This session highlights common mistakes made by web programmers, stating the problems and avoidance techniques.

AJAX: Creating Next-Generation, Highly Dynamic, Off-line Capable Web Applications with HTML and JavaScript

As recent high-profile web apps such as Google's GMail have shown, modern browsers are capable of natively rendering web apps with highly dynamic and compelling UIs - fetching server data without page refreshes, animating and manipulating page contents on-the-fly, even offline use. The line between web and "desktop" apps is blurring.

Advanced Swing: Architecture and Frameworks

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.

Creating Polished Swing Applications

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.

Advanced Hibernate

Hibernate is easy to get started with, but can sometimes be hard to make efficient or secure. In fact, the default settings for Hibernate createapplications that will run slowly, cause unwanted round trips to the database, and may be more restrictive and/or permissive from a security standpointthan you would otherwise want.

Introduction to Hibernate

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.

Spring MVC

The Spring team, as in all things they do, have learned the valuable lessons of the past when introducing a Spring solution. Spring MVC is everything Struts should be, and more besides.

Spring Security with ACEGI

Spring offers developers a simpler, more robust method for configuring applications. These benefits extend to security through the ACEGI framework. ACEGI makes the otherwise daunting task of securing your application logical and straightforward. More importantly, through its support for single sign-on provision through Yale's CAS system and its ability to provide instance-level authorization, Spring extends the common security model of most J2EE apps beyond what they are traditionally capable of.

Writing Secure Web Services (with Java and Axis)

Web Services are message-oriented. This means that any application intention (the need for security, for transactionality, for reliability, etc.) must be included in the message and not just assumed as external context. The WS-Security specifications are very advanced and currently being used in the wild to create robust, secure web services.

Class Loading in Java: Building Dynamic Systems Without Pain

(3 Hour Session) One of Java's greatest strengths is its flexible deployment model. In this session you will learn how Class Loaders facilitate deployment, and how to troubleshoot Java and J2EE Class Loading problems.

Cryptography for Programmers

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.

Java Platform Security and JAAS

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.

Aspect-oriented Refactoring: Taking Refactoring to a New Level

Refactoring allows reorganizing code while preserving the external behavior, while AOP facilitates modularizing crosscutting concerns in a system through use of a new unit of modularity called aspect. Aspect-oriented refactoring synergistically combines these two techniques to refactor crosscutting elements. Individually, refactoring and AOP both share the high-level goal of creating systems that are easier to understand and maintain without requiring huge upfront design effort. A combination of the two -- aspect-oriented refactoring -- helps in reorganizing code corresponding to crosscutting concerns to further improve modularization that is easy to understand, highly consistent, and simple to change.

Design Pattern Modularization with AOP

Design patterns -- object oriented, concurrency control, and J2EE -- all have certain crosscutting elements present. The obvious result of conventional implementation is unclear implementation that is tedious to implement and tough to change. Aspect-oriented programming (AOP) offers a way to simplify implementation of these design patterns. Further, AOP offers new design patterns of its own that allow for new ways of implementing functionalities. This session shows how the use of AOP can simplify implementation of design pattern.

Introduction to Aspect-oriented Programming with AspectJ

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.

Performance Monitoring in J2EE Applications

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.

Java Transaction Management Part 1

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.

Java Transaction Management Part 2

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.

Making Architecture Work Through Agility

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.

Applied Design Patterns

Just about every modern software developer has a copy of the Gang of Four "Design Patterns" book sitting on a shelf; many of them have actually read it. The dark secret of the patterns community is that there is often a large gulf between whiteboard simplicity and real-world complexity. Language choice plays a part in the design (and even importance) of patterns. The situation is made even more confusing by the fact that many of the core patterns have now been "voted off the island" for one reason or another. This talk will give a pragmatic overview of the motivations behind design patterns and will focus on applying a handful of the GOF patterns to example scenarios in Java, Ruby and C#. A quick introduction to the role AOP plays in changing the patterns landscape will also be covered.

Applied Object-Oriented Metrics

Object-oriented code metrics are a little like Artificial Intelligence: those who did it twenty years ago roll their eyes at the thought and prophesy the same ultimate failure at applicability now. Those who grew up with Java are approaching the topic with new eyes and are finding useful ways of incorporating metrics into their projects. Come hear about tools and ways to measure properties of software, how they might be beneficial and where you are likely to go astray with this approach.

JmDNS : Easy Service Discovery for the 21st Century

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

Good, Bad and Ugly of Java Generics

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.

Prudent OO Design

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.

Test First Development

Do you know that unit testing is more of an act of design than verification? What are its benefits? How do we write effective tests? How does unit testing relate to evolutionary design? How does it help you with refactoring? When should you write your tests? What are the types of tests you could write? These are some of the questions that you would ask if you are interested in Unit Testing. What is a better way to learn than practicing it? In this session the attendees will participate in designing and developing a small yet full application. Instead of PowerPoint slides, you will learn from example. The code you help develop will be available for free download on the speaker's web site.

Beyond Java

All programming languages have a limited life span, and Java is no different. This is a philosophical session rather than a programming session. Sooner or later, Java will lose its leadership position. This session will explore Java's strengths and weaknesses. We'll try to understand whether conditions are ripe for alternatives to emerge, and what those alternatives may be.

Introduction to Spring

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.

Politics of Persistence

This session will help a Java developer choose a persistence framework. After the session, you will • Understand the core strengths and weaknesses of the main persistence frameworks in the Java space • Understand where marketing influences can impact persistence • Know what’s going on behind the scenes to impact the persistence pictures • Answer questions about persistence frameworks that might not be mainstream

Herding Racehorses and Racing Sheep

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?

Ruby for Java Programmers

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.

Ruby on Rails

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