Session Descriptions

Internationalization and Localization in Java

Internationalization and Localization in Java is easy, right? Everyone knows you just store your strings in some resource bundles, set the locale, wave your hands a little bit, and your application is good-to-go. Right? Maybe not... Java provides some great utilities to get started, but leaves you needing more when it comes to things like screen layout, cultural sensitivities, semantic differences in translation, use of color and iconography, and other issues.

Introducing Agility to Large Organizations

For several years, I was a member of a team of people caught in the middle of a 200+ person software development company, with senior management wanting "buzzword compliant process improvement" such as CMMI, and engineers wanting more ?agile? solutions (and people on both sides confusing Agile with ad-hoc). We were responsible for sorting it all out. Reconciling this was a herculean effort, and can be a source of lessons learned for your own process improvement efforts. Are you trying to be more agile in your organization? Are you expecting it to be harder than it needs to be because of political and bureaucratic forces beyond your control? Do you have to "educate" your senior management to protect them from buzzwords? Come learn from my successes... and mistakes.

Maintaining Project Integrity with JDepend, Macker, PMD, Maven, and other open source tools

How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? How many times have you been the ?new guy? on an established project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good structural guidelines and several tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.

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.

Advanced Metaprogramming With Groovy

The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.

Advanced Techniques With Grails

Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. Grails provides simple mechanisms for leveraging the power of Ajax.

Groovy For Java Programmers

Groovy is an agile dynamic language for the Java platform. Groovy has a Java like syntax along with many features inspired by languages like Python, Ruby and Smalltalk. This session covers a lot of ground including many interactive examples to hilite the powerful language features that make Groovy compelling. A lot of momentum is building in the Groovy and Grails communities right now and this session is aimed at Java developers who want to leverage the power of Groovy.

Introduction To Agile Web Development With Grails

Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring, Sitemesh and Quartz to make web application development both fun and easy.

Test Driven Development With Groovy And Grails

The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.

Developing Enterprise Business Applications in Eclipse RCP

This tutorial emerges out of the combined experience the presentor gained while working on a large Eclipse RCP/J2EE enterprise application (2.3 million lines of code in the RCP application). It will address the gap between the standard functionality of Eclipse RCP and what is needed for the creation of polished highly usable business applications.

Introducing the Eclipse Rich Client Platform

Rich client application development using Java can be intimidating giving the vast flexibility in application design and structure. It also can be frustrating to create the large number of support services (persistence, menus, event and job frameworks) that a large scale rich client applications needs. The Eclipse Rich Client Platform is one project attempting to solve these issues by providing a core infrastructure that not only provides the day to day services a rich client application developer needs, but also providing a suggested path to guide you down the road of designing your application. This presentation introduces both the Eclipse RCP and the tools provided by the Eclipse IDE that assist developers in writing RCP apps.

JRuby

JRuby is not one, but two great technologies: the Ruby language, and the Java Virtual Machine and libraries. In this talk you will learn the basics of programming JRuby, and how to integrate JRuby code into existing Java projects.

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.

Creating Agile Requirements

Successful project communities balance written requirements with a healthy amount of discussion. This is at the core of requirements that could be deemed "agile". Many agile projects choose to use user stories, but others may be using use cases or other forms of written requirements. This session is for anyone wanting to improve their requirements, including the creation of good requirement and the presentation styles that help people focus on creating great software products, and stop focusing on documents.

Executable Documentation

Why is so much documentation worthless? Wouldn't is be nice if your documentation actually reflected what your system does? One way to do this is to create what is being called executable documentation or executable specifications. If you are struggling with ambiguous requirements, lack of contact with the business, or a chasm between development and testing, this session is for you.

Getting Agile Planning and Tracking Up and Running

If your company is using agile or thinking about it, this session will show you how to plan and tracking an agile project. Examples projects will be discussed, including the glory and horrors. Various planning tools that help distributed teams will be presented as well as a collection of lo-fi tools which truly help find and address the issue that plagues so many projects: "when are we going to complete this project".

Leading Agile Projects: Finding Your Groove in the First 4 Iterations

Although there are many books about agile, but few provide a path for guiding you through the beginning of an agile project. Whether you are preparing for your first agile project, or taking the lead for the first time, this session will provide a guided tour filled with practical advice and a pile of anecdotes.

Leading Agile Projects: Maintaining Sustainable Agility

Once your agile project is rolling along, there are many bumps and roadblocks which can derail the train. Whether you are leading the project formally or informally, there are techniques you can use to keep the project alive and innovative. This session will cover skills and techniques for leading sustainable project communities.

Prerequisite: Leading Agile Projects: Finding Your Groove in the First 4 Iterations

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.

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.

Exploring the JavaServer Faces Ecosystem

This session examines the ecosystem of products built on JavaServer Faces.

Prerequisite: Basic familiarity with web application development in Java.

Cluster your Cache with Hibernate and Terracotta

Terracotta (an open source technology) provides a clustered, durable, virtual heap. You can reduce the load on your database by allowing Terracotta to handle sharing and persistence of temporary conversational state in your web application. One option is to simply cluster your existing Hibernate L2 cache (for instance with ehcache).

A higher performance option is to disconnect your POJOs from the Hibernate session and manage them entirely in Terracotta shared heap until they are ready to be written back to the system of record. This option can yield extremely high performance while simultaneously reducing the load on your database, allowing you to scale your system with significantly less hardware.

Collections 201

Did you know that Java 5 and 6 added 8 new interfaces and 16 new collection implementations to the JDK, more than doubling the size of the collection API? Collections 201 gives you an update on all of the interfaces, implementations, and utilities and gives you guidance on picking the perfect collection. In particular, Java 5 introduced a new major collection type Queue and a whole new java.util.concurrent package with data structures optimized for concurrent use.

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 Concurrency (Part 1: Threads)

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

The Busy Java Developer's Guide to Concurrency (Part 2: Concurrency)

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

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 Java Platform Security

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

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?

Why the Next Five Years Will Be About Languages

Thanks to the plateau of per-chip performance increases and the resulting need to work better with multi-core CPUs, the relative difficulty of mapping user requirements to general-purpose programming languages, the emergence of language-agnostic "virtual machines" that abstract away the machine, the relative ceiling of functionality we're finding on the current crop of object-oriented languages, and the promise and power of productivity of dynamically-typed or more loosely-typed languages, we're about to experience a renaissance of innovation in programming languages.

Design for Operations

If your software fails in production, nobody will care how great the development project was, or how well the system passed QA. Production operations, the domain of your systems' least-appreciated stakeholders, is where the rubber meets the road. Come learn how to build your systems to thrive in Operations.

Failures Come In Flavors (part 1)

The typical JEE application does not reach the fabled "five nines" of availability. Far from it. It's more like "double eights". Come see why enterprise applications and web sites are only serving users 88% of the time instead of 99.999%.

Part 1 of 2

Failures Come In Flavors (part 2)

What can we do about the dismal uptime of typical applications? We are asked to provide "five nines", but only reach 88%, on average. Come learn how to prevent the Stability Antipatterns from biting you. Apply these Stability Patterns to contain damage, recover from shocks, and survive disasters.

Part 2 of 2

Comparing Java and Groovy

With interest in Groovy continuing to rise, many Java developers are wondering how Groovy differs from Java, and what benefits they may gain from this new language. This presentation highlights the differences between Java and Groovy by exploring some code solutions written in each language.

Implementing DSLs with Groovy

Domain Specific Languages (DSLs) have been a powerful technique used throughout programming's history to elevate developer productivity. This talk will discuss how to create and use DSLs with the Groovy programming language. Different techniques for creating DSLs will be shown, along side an exploration of the features in Groovy that make it especially useful for DSLs.

Introduction to Java Cryptography

Cryptography is an essential part of many applications, from simple e-commerce applications to back-end credit card processing systems to highly sensitive customer information. This session covers basic concepts of Cryptography and how they are used in the Java programming language.

JMX and Spring: Manageability for Spring-based Applications

This session describes management of Java resources using the Java Management Extensions JMX API. JMX provides a unified framework to instrument Java systems with monitoring and management capabilities.

Java Memory, Performance and the Garbage Collector

You are using Java, whew!!! No need to worry about memory, the garbage collector will handle that. Those who have had a memory issue in Java are not so naive any more. Often memory utilization and heap sizes are an after thought and are not recognized until the application is in production, often caused by application uptime, production request volume or production sets of data. When the OutOfMemory Error occurs, often the science of development seems to brake down and knobs are turned. First the (-mx) maximum heap space gets adjusted... More is better right. The next OutOfMemory, heads start scratching, code reviews start in earnest, and Google gets several new hits. Did you know that it is possible to get an OutOfMemory error without running out of heap space?

Google Web Toolkit (GWT)

This talk introduces the GWT, an open-source, Java-based framework for creating Ajax web applications.

Exploring Maven 2

Learn how to clean up your build process with Maven 2.

Spring Cleaning: Tips for managing XML clutter in your Spring configuration

The biggest complaint about Spring is the vast amount of XML required to configure an application. In this presentation, I'll show you ways to reduce or even eliminate much of the XML required to configure Spring.

Spring in Action

Spring has been one of the most exciting frameworks to emerge in the past few years. With Spring you can decouple your application's objects, enrich them with AOP, and apply transactional boundaries and security to them declaratively. It simplifies data access, remoting, web services, and JMS. It comes with its own web framework. And, even though Spring eliminates much of the need for EJBs, it will still integrate nicely with any EJBs you may have lying around. What's not to love?

Spring-WS: Contract first web-services for Spring

Many web-service platforms make web-services easy by simply SOAP-ifying an object's interface. That's certainly a quick way to get started with web-services, but what happens when the object's interface changes?

Java Content Repository (JSR 170)

Many developers think the Java Content Repository (JSR 170) is only useful for building Content Management Systems. As Tom Wheeler points out in this presentation, it's actually an overlooked and versatile API for general data storage and retrieval. Offering features such as transaction management, remote access and versioning, the Java Content Repository has the potential to replace RDBMS, XML documents, properties files and other data storage mechanisms.