Session Descriptions

Unit Testing - Java, Groovy and JRuby

TDD has been around for a long time. And the tools available to write and use your unit tests continue to improve. Some of the tools we use on a regular basis include JUnit, the most popular testing frameworks, Cobertura, a test coverage analysis tool and jMock, a Mock Objects library that allows you to test the interactions between your objects. Less common, but quickly becoming popular is the practice of writing tests using dynamic languages such as Groovy and Ruby.

Why Test Driven Development?

Test Driven Development is a central tenet of Agile software development methodologies and is a powerful design technique for any software developer. The reasons for this are many: it encourages more modular, simpler code. It helps you avoid YAGNI. It can be used to document a software system, by providing a specification and examples of its use. A test suite, is also a necessary safety net for any serious refactoring work.

Groovy and Java: The Integration Story

I'm attracted to Groovy because of its spirit of inclusiveness. Because it extends my platform of choice, not replaces it -- include a single JAR in your classpath and you are Groovy-enabled. Because it offers full bidirectional integration with Java. Because it offers a nearly flat learning curve for experienced Java developers. Come see how you can use Groovy to augment your existing Java codebase.

Groovy: The Next Generation of Java

This is the year of the dynamic scripting language. Ruby (and Rails) has won the hearts and minds of many independent software developers. JavaScript is experiencing a renaissance thanks to the wild success of AJAX and websites like Google Maps. And Groovy (JSR-241) brings the same level of excitement and "scripting goodness" to the Java platform.

KEYNOTE: No, I Won't Tell You Which Web Framework to Use: or The Truth (with Jokes)

"Which framework should I use?" is the question most often heard on the No Fluff, Just Stuff tour. It's well worth asking. Unfortunately, there is no simple answer. After years on the tour, most speakers have crafted a response that would make any Washington politician proud -- long on style, but essentially, "Well, it depends..."

Mocking Web Services

In this talk, we'll survey the web services exposed by leading websites (Google, Yahoo, Amazon, eBay) and discuss how they can be easily mocked up for testing purposes and to aid offline development. You'll see working examples of RESTful, SOAP, and JSON web services, as well as strategies for unit and functional testing your asynchronous, service-oriented architecture.

The Secrets of GORM

GORM (the Grails Object/Relational Mapper) is one of the many high points of the Grails web framework. GORM is a thin Groovy wrapper over Hibernate, but that doesn't begin to capture excitement of what GORM brings to the party. Imagine being able to call book.save() and book.delete() on your Book class; calling Book.get(1) to retrieve your book from the database by primary key; using Book.list() to pull an ArrayList of Book objects into your application. Now imagine getting all of that functionality (and more) for free with each new class you define. No interfaces to implement. No abstract classes to extend. Persistence that is transparent, automatic, and simple to use: GORM.

The Zen of REST

Google quietly deprecated their SOAP search API at the end of 2006. While this doesn't mean that you should abandon SOAP, it does reflect a growing trend towards simpler dialects of web services. Google joins a number of popular websites (Yahoo, Flickr, YouTube, del.icio.us) that offer all of the benefits of web services without all of the complexity of SOAP.

Enterprise Security with Spring

Spring Security (formerly known as 'Acegi') enables self-contained, consistent, and extensible solutions for securing your applications. Version 2.0 provides major enhancements including a domain-specific XML namespace, convention-based defaulting, and annotation support. This provides a significantly simpler experience for developers while still supporting the same degree of flexibility.

Message Driven POJOs with Spring

Spring 2.0 introduced support for Message-Driven POJOs meaning that it is now possible to receive JMS messages asynchronously and delegate the handling of those messages to simple objects even within a lightweight application running outside of any application server. If your POJO has a return value, it will automatically be sent to a response destination.

Spring 2.0: New and Noteworthy

Spring 2.0 has marked a major advance in the Spring Framework. While still maintaining backwards compatibility, this release adds quite a few new features. What are those features and how do they add value? Come by and see.

In this session we'll provide a practical tour of what's new in Spring 2.0. Spring 1.x users who are looking to upgrade to Spring 2.0 will love this session. If you're not using Spring already, this talk will give a great overview of the things you're missing out by not using Spring 2.0.

The Role of Spring in an ESB

An Enterprise Service Bus (ESB) brings flow-related functionality such as message routing and transformation to a Service-Oriented Architecture. An ESB also provides a layer of abstraction with endpoints for various protocols and transports. These features promote decoupling of integration logic from business functions, flexibility in the transport layer, and pluggability of POJO services.

Building DSLs in Static and Dynamic Languages

This session discusses building Domain Specific Languages and DSL-style code in Java, Groovy, and Ruby. It discusses the different types of DSLs, details on how to implement them in Java, Groovy, and Ruby, and example problem domains where DSLs make sense.

Implementing SOA

This talk avoids SOA hype and gets to the meat of the matter: how do you implement a Service-Oriented Architecture, what are the technological pitfalls, how do you test it, and what traps should you avoid. No marketecture: just implementation details.

Introduction to JRuby

This session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.

Productive Programmer: Acceleration, Focus, and Indirection

This session discusses how to use the Productive Programmer principles of acceleration, focus, and indirection to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.

Productive Programmer: Automation and Canonicality

This session discusses how to use the Productive Programmer principles of automation and canonicality to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.

Rails for JRuby

This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment...on the JVM, using JRuby.

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.

The Productive Programmer: Practice (10 Ways to Improve Your Code)

No one writes perfect code: even the best developers fall into bad habits and traps. These topics from The Productive Programmer illustrate blind spots and helps you write better code.

Beyond ACID: transactions management, in theory and practice

Transactions are the software building blocks of enterprise applications, but not all transactional systems are created equally. This talk covers the basics of what transactions are, why they are essential to building reliable enterprise software, the fundamental properties of transactions, and how transactions are supported and implemented in popular frameworks such as Java EE and Spring.

Effective Concurrent Java

The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support of multithreading. However, the Java concurrency primitives are just that: primitive. From them you can build many concurrency utilities, but doing so takes great care as concurrent programming poses many traps for the unwary.

Java Performance Myths

Performance myths about the Java platform abound, from the general "Java is slow", to the more specific "reflection is slow", "allocation is slow", "synchronization is slow", "garbage collection is slow", etc. Many of these myths have their root in fact (in JDK 1.0, everything was slow); today, not only are many of these statements not true, but Java performance has surpassed that of C in many areas, such as memory management.

Structuring concurrent applications in JDK 5.0

JDK 5.0 is a huge step forward in developing concurrent Java classes and applications, providing a rich set of high-level concurrency building blocks.

The Java Memory Model

What's the worst thing that can happen when you fail to synchronize in a concurrent Java program? Its probably worse than you think -- modern shared-memory processors can do some pretty weird things when left to their own devices.

JavaScript for Java Programmers

This presentation covers JavaScript from the perspective of a Java programmer. We assume that you may be using an Ajax toolkit, but still need to be able to read, modify, and test the JavaScript code in your application. You will learn the common idioms of JavaScript by looking at working code from Prototype and Scriptaculous.

Prototype: Ajax and JavaScript++

Learn to simplify Ajax development with Prototype through a series of real-world examples. Along the way, learn to code in Prototype's modern JavaScript style, taking advantage of Prototype's extensions to JavaScript's object model

Screwing Up Agile

Agile software techniques like Scrum and XP are increasingly popular; there are tons of resources on the web to help you do agile right. Tragically, there are very few resources to help you screw up an agile project. This talk will show you how to ruin agile projects.

This Week In Refactoring

Contributing to open source is great for your career. In a few short hours, you can learn, teach, promote your skills, and improve the quality of the community. In this talk, we will show you how, by doing it.

AJAX and JSF: Natural Synergy

With the emergence of AJAX as a preferred way of building web user interfaces, JavaServer Faces (JSF) has proved itself to be a natural fit for integrating AJAX with Java sever-side logic.

Architecting JavaServer Faces Applications

Over the past few years, a lot of time has been spent explaining what JSF is, and how different pieces of it work. However, little attention has been given to the process of architecting applications. This makes JSF architecture seem like a black art, since there are so many possible approaches to the application's architecture.

Prerequisite: Experience with JavaServer Faces.

Building Enterprise Applications with JavaServer Faces and Spring

For developers who are currently using Spring and JavaServer Faces together, this session explains how to handle common application development concerns such as conversational scope, transaction management, and application partitioning.

Introduction to JBoss Seam

JBoss Seam is a popular open-source application framework for Java Platform, Enterprise Edition (Java EE) 5.0. For web application developers, a significant benefit of Seam is that it greatly enhances JavaServer Faces technology. This session explains key Seam features such as tight integration with EJB3, Hibernate and JPA integration, conversations, RESTful web pages, and so on.

Prerequisite: Basic understanding of Java web application development. Familiarity with Dependency Injection/Inversion of Control, JSF, and JPA/Hibernate persistence is a plus.

Java6: Exploring Mustang

Mustang, the Java6 release, is out, and even if you're not looking to adopt the new platform right away, it's important to know what's there so you can start to plan for it. In this presentation, we'll go over the major new features of the Java6 platform, including the new integrated XML services capabilities (JAX-WS and JAXB), dynamic/scripting language support (javax.script), new JVM "attach" capabilities, new annotations supported by the javac compiler, and more.

The Busy Java Developer's Guide to Annotations

Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).

The Busy Java Developer's Guide to Debugging

Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to have some basic ideas about bug-tracking in your toolbox. Learn to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.

The Busy Java Developer's Guide to Performance and Scalability

Wondering why your enterprise Java app just... sucks? Trying to figure out why you can't get more than 10 concurrent users online at the same time? Looking for ways to try and spot the slowdowns and ways to fix them?

Agile Software Testing Strategies

Creating and maintaining a solid automated test suite is critical to an Agile strategy, but often we're just told to "Do it." In this talk we'll look at several pragmatic strategies for creating and building your suite.

Build Teams, Not Products

A great team builds great software, but how do you build a great team?

Distributed Teams: Remote Agility

How do you keep a team scattered across time zones in sync?

Shippers Unite!

An overview of the Agile software approach from the book Ship It! A Practical Guide to Successful Software Projects.

Software Development Techniques

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.

Advanced Domain Models in Grails: Enterprise Integration Made Easy

Have you seen someone develop a Rails or Grails application in a matter of minutes, only to later discover that their domain model and database schema followed conventions that are different from your existing systems? Or perhaps you're interested in using Grails, but you don't want to duplicate your existing Java domain classes in Groovy. In this session, we'll see how Grails makes it easy to hook into your pre-defined schemas or existing entity classes, while still getting all the rapid application development (RAD) goodness that Grails has to offer.

Getting Started with Grails

Grails is an open-source web application framework that's all about getting things done. Grails combines best-of-breed Java technologies (including Hibernate and Spring), convention over configuration, and the powerful and dynamic Groovy language. Together with these elements and Groovy's ability to seamlessly integrate with your existing Java code, Grails finally legitimizes rapid web application development for the Java platform.

Going Further with Grails

Grails provides a tremendous jump-start to any web application. With easy scaffolding and zero-configuration ORM, you're up and running in no time. But what's needed to effectively move from a vanilla Grails project to a fully-customized application fit for public consumption?

10 ways to use Hibernate effectively

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Beginning Drools - Rule Engines in Java

Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

Beginning Object-Relational Mapping with Hibernate

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

Professional Java UI development with the Eclipse RPC

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application.

Domain Driven Design

Domain Driven Design (DDD) is an approach that places emphasis on the domain model and carrying it into implementation. DDD is mostly repackaging of fundamental OO Design. It brings new emphasis to what we should be already doing, but often find it hard and confusing given the realities and complexities of our real world. In this presentation we will take a close look at what DDD is and how to use it for agile development. We will discuss several design options, and also look at some examples of good modeling and layering.

FP for Java Programmers

Most interest around Functional Programming (FP) has been academic until recently. Recent commercial languages are beginning to exploit FP features. Knowing more about FP will not only help us make better use of these features, but to exploit those. In this session we will take a close look at FP.

OSGi: A Well Kept Secret

In this presentation we will introduce OSGi and discuss how it can help modularize and version your enterprise Java applications.

get Fit

Unit testing tells you, the programmer, that your code (and the change) meets your expectations. How do you know if you are meeting your customers' expectations? Agile development is all about feedback and doing what's relevant to the customers, isn't it? Framework for Integration testing or Fit helps you to automate tests for customer expectations.

JBoss ESB Deep Dive

This session will be a deep dive into the capabilities of the open source JBoss Enterprise Service Bus 4.2 GA. An ESB is primarily categorized by its capabilties in the areas of protocol mediation/abstraction, transformation, orchestration, routing, endpoint registry, etc. Numerous live demos of ESB functionality.

Open Source SOA

At some point, code will be written, software tools will be acquired and systems will be built. Unfortunately the Java development world is a confused mess as it relates to a method of building a Service Oriented Architecture (SOA)-based anything. Our objective is to answer the following questions: Should I use Web Services everywhere? Is an Enterprise Services Bus (ESB) useful and required? Should I be programming in the XML-based syntax of BPEL instead of Java? Do I need JBI and/or SCA? What Open Source implementations are available to solve SOA related challenges?

Creating Manageable Systems with JMX

Starting with the Java 5 programming language, it has gotten easier to incorporate monitoring and manageability into any application running on a standard VM. Developers now have access to a wealth of runtime VM profile information exposed through Java Management Extensions (JMX), including memory consumption, garbage collection, and thread activities (with even more capabilities in the Java 6 programming language). Using JMX, developers are also able to expose runtime control and management information for their own applications.