By Neal Ford

This session demonstrates that "Agility" and "SOA" complement each other quite well. Just because SOA is buzz-word compliant doesn't mean that you should throw good practices out the window. This session demonstrates how you can apply the principles of agility to building highly complex distributed enterprises.

Managers and ivory tower architects seem to think that all the rules that apply to "normal" software don't apply to SOA. Ironically, they matter even more. Agility and SOA are closely aligned because SOA is about building complex distributed systems and Agility is about effectively building complex software. This session unveils the pillars of successful SOA and how to achieve them in a testable, iterative fashion. It discussing testing strategies, how to make your architecture more robust and maintainable, and how to design an evolutionary architecture.

By Neal Ford

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.

It is too easy to get into a coding slump and not realize it. This talk revitalizes your relationship to code, forcing you to rethink some of the thing that you take for granted and showing new approaches to solving hard problems. It covers topics that range from improve the overall structure of your code to the way you write JavaBeans, with lots of examples. Everything in this talk may not be new to you, but I guarantee that you'll see some things that will make you reevaluate the way you think about your code.

Session Outline: TDDStatic AnalysisGood Citizenshipgetters and setters ConstructorsStatic StateYAGNIOccam and His RazorQuestion AuthorityDSLsJavaBean Specification SLAPNew Langua

By Neal Ford

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.

This session shows how to fully exploit regular expressions. It begins with the basic premise of how regular expressions work, then shows how to take advantage of the RegEx library built into the Java platform. This session shows how to use wildcards, escape characters, meta-tags, character class operators, look-aheads/look-behinds, and how to use the greedy operators effectively. It covers regular expressions from the beginning through to advanced usage, both in Java and in tools that support regular expressions. This session is packed with real examples of regular expressions (including a game show with no fabulous prizes).

Key Session Points:

Regular expressions defined

Examples

Using t

By Neal Ford

It turns out that ancient philosophers knew a lot about software -- did you know that Plato defined object-oriented programming? This keynote applies old lessons to new problems and old problems to new lessons. It describes why SOA is so hard, and why people in your company make bone-headed decisions. What other keynote includes Rube Goldberg, Aristotle, Dave Thomas, and Chindia?

Plato, Aristotle, Occam, Rube Goldberg, Dave Thomas, and Demeter...with pictures!

By Neal Ford

Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!

In The Productive Programmer, I identify 4 principles of productivity: this talk goes into great detail on 2 of those principles. It defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Automation refers to making the computer do more work for you. This talk includes tons of examples, all culled from real-world projects. Note: This is a companion talk

By Neal Ford

Getting work done in modern office environments is a daunting task. This session tackles 2 of the things that drag down developer productivity: lack of focus and creeping repetition.

In The Productive Programmer, I identify 4 principles of productivity: this talk goes into great detail on 2 of those principles. This session defines the principles of Canonicality and Focus, and describes their use. But the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Canonicality (the DRY principle from The Pragmatic Programmer) discourages repeating artifacts in projects. This talk shows effective ways to avoid this repetition. I show examples of creating DRY documentation, O/R mapping, database schemas, and development environments. Focus describes how you can utilize your environment (both physic

By Neal Ford

What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.

Agile projects focus on delivering code. The responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools (both byte and source code), useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks.

Session Topics:The Hawthorne EffectHow Agility and Metrics Feed Eac

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

By Ted Neward

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

For an intermediate Java audience.

By Ted Neward

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.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

By Ted Neward

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.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

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

By Ted Neward

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.

For an intermediate-level audience.

By Ted Neward

If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.

For a beginning to intermediate Java audience.

By Ted Neward

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.

Learn to use jdb, jconsole, jps, jstat, and other tools to identify and squash software defects that just won't reveal themselves during development. Then, just in case those tools aren't enough for you, we'll look at how to write your own, special-purpose tools using the same technology backplane.

By Ted Neward

Crashes? Outages? Slow response? We all know that it's never your code that causes these things, but for some reason those pesky system administrators still insist on paging you at 4AM to come in and fix those problems, anyway. For some reason, they just keep expecting you to support this thing, even after QA said it was OK!

In this presentation, we'll talk about some of the reasons why monitoring in a production application is so important, and why it's not just a system administrator concern. Next, we'll talk about some simple monitoring facilities that don't require any new APIs or new libraries, yet still deliver some useful monitoring capabilities to developers, sysadmins and management. Next, we'll look at using JMX tools to keep an eye on what's going on inside of the JVM itself and/or your applications server, then how to use JMX to create your own points of monitoring interest. Finally, we'll look at how system administrators can build their own monitoring tools by using languages like Groovy and/or JRu

By Ted Neward

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files.

Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more.

Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

By Ted Neward

Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play.

In this presentation, we'll examine several of the "hackable" customization points inside the JVM: the boot classpath, allowing us to add or modify existing JDK classes without violating the license agreement; the JNI Invocation API, allowing us to create custom Java launchers to establish an environment for the JVM that corresponds to exactly the way we want it; or even replace core Java classes with our own versions. Innocents beware--we're a long way from "Hello, Java". (Attendees should have some familiarity with C/C++ code and native build practices to get the most out of this talk.)

By Nathaniel Schutta

It seems that software follows the second law of thermodynamics - in other words, code tends towards disorder. Of course it doesn't have to be that way, and we have a number of tools and techniques that we can apply to keep our code in tip top shape. This talk will discuss ten things you can do to fight back!

It seems that software follows the second law of thermodynamics - in other words, code tends towards disorder. Of course it doesn't have to be that way, and we have a number of tools and techniques that we can apply to keep our code in tip top shape. This talk will discuss ten things you can do to fight back!

By Nathaniel Schutta

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

By Nathaniel Schutta

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

By Nathaniel Schutta

Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language.

This session will give you an overview of this misunderstood language as well as opening your eyes to some of the excellent tools available to ease the pain of developing in this dynamic language.

By Nathaniel Schutta

We all know that code can have a certain...odor but frankly so can projects. Everyone has their favorite horror story or tale of a death march. In this talk, we'll discuss common project smells and what you as a developer can do to maintain your sanity - and your hair line!

We all know that code can have a certain...odor but frankly so can projects. Everyone has their favorite horror story or tale of a death march. In this talk, we'll discuss common project smells and what you as a developer can do to maintain your sanity - and your hair line!

By Venkat Subramaniam

Java has been around for well over a decade now. It started out with the goal of being simple. Over the years, its picked up quite a bit of features and along comes complexity. In this presentation we will take a look at some tricky features of Java, those that can trip you over, and also look at some ways to improve your Java code.

Java features

Set of tricks

Tips to improve your Java code

By Venkat Subramaniam

We all have seen our share of bad code. We certainly have come across some good code as well. What are the characteristics of good code? How can we identify those? What practices can promote us to write and maintain more of those good quality code. This presentation will focus on this topic that has a major impact on our ability to be agile and succeed.

Characteristics of quality code

Metrics to measure quality

Ways to identify and build quality

By Venkat Subramaniam

Functional Programming Languages (FPLs) have been around for a long time. A lot of features that we get excited about in dynamic languages are common place in FPLs. FPLs are gaining importance due to various changes in our industry. What's exciting is that you can use them on the JVM. In this presentation we will dig into the details of what makes FPLs so interesting and look at ways to use them on the JVM?in your Java projects.

What's Functional Programming?

Why is Functional Programming suddenly important?

Features of Functional Programming

Functional Programming Languages

JVM and FPLs

Examples of Functional Programming features

Examples of mixing Java and FPLs

By Venkat Subramaniam

You're most likely familiar with the Gang-of-four design patterns and how to implement them in Java. However, you wouldn't want to implement those patterns in a similar way in Groovy. Furthermore, there are a number of other useful patterns that you can apply in Java and Groovy. In this presentation we'll look at two things: How to use patterns in Groovy and beyond Gang-of-four patterns in Groovy and Java.

Patterns overview

Implementing common patterns in Groovy

Beyond Gang-of-four patterns in Java and Groovy

Lots of examples

By Venkat Subramaniam

Groovy's dynamic and Meta Programming capabilities makes it a great tool for unit testing. In this talk we will take a look at how we can use Groovy for unit testing and creating mocks both for testing Groovy code and Java code.

Unit Testing

Groovy's strengths and capabilities

Writing tests in Groovy

Groovy's convenience methods for asserting and testing

Mocks and tests

Groovy techniques for mocking Java and Groovy code

By Venkat Subramaniam

DSL or Domain Specific Languages focus on a domain or problem at hand. They're expressive, but their restricted scope keeps them simple and small from the user point of view. However, designing them is not easy. In this presentation we will explore the features of Groovy and show how they can be used to create DSLs.

What's DSL?

Characteristics of DSLs

Types of DSLs

Designing DSLs

Groovy features that enable DSLs

Examples of DSLs in Groovy

Creating DSLs in Groovy

By Venkat Subramaniam

Groovy's dynamic capabilities makes it an attractive language for Meta Programming. There are several facilities to intercept method calls to do AOP kind of operations. You can also inject methods dynamically. You can also easily perform method synthesis as well. In this presentation we will take a look at techniques that make Groovy pretty Hip for MOP.

Exploring MOP

Understanding Groovy's method handling mechanism

Accessing methods and properties dynamically

Method interception

Method injection

Method synthesis

Method delegation

Applying MOP to real world projects

By Venkat Subramaniam

Dynamic languages provide some great capabilities for adding dynamic behavior to your Spring applications. In this presentation we will take a look at the various options for mixing dynamic languages with Spring.

You will take away tips on how to enhance your Spring applications using languages like Groovy and JRuby.

By Venkat Subramaniam

How do you ensure your applications meet the expectations of your key customers? In this session we will explore using the FIT tool and Behavior Driven Design tools to do exactly this.

Unit Testing helps you, the programmer, verify your application meets and continues to meet your expectations. But how do you ensure that your application meets and continues to meet the real expectations, those of your domain experts and key customers? We will take a look at two distinct approaches for customer acceptance testing. We will take a look at using FIT for testing behavior and at Behavior Driven Design tools and techniques. Both these approaches can helps us create what is called executable documentation and to stay sane in the world of changing requirements and evolutionary design.

By Venkat Subramaniam

OSGi is a specification that helps with versioning Java modules at runtime. Spring helps with dependency injection of Java components and beans. Spring has embraced OSGi and allows you to integrate different OSGi implementations into your Spring applications. In this presentation we will look at the rational for mixing Spring and OSGi and look at code examples of the same.

What's OSGi?

OSGi features

Spring integration with OSGi

Examples of using OSGi in Spring

By Craig Walls

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?

Everyone's favorite Java framework continues to improve, with significant enhancements in Spring 2.5 and many more slated for Spring 3.0. Maybe you've already seen or read about

Spring and perhaps you've even developed applications using Spring. But have you seen the latest that Spring has to offer.

In this example-driven presentation, I'll lead a guided tour through the key features of Spring, with an emphasis on the Spring's core facilities of Dependency Injection and Aspect-Oriented Programming. Whether you're a Spring newbie or a seasoned Spring developer, there'll be something new for nearly everyone.

By Craig Walls

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.

A typical Spring configuration file will contain dozens (or even hundreds) of lines of XML. Because of all of the XML clutter, some have started looking for alternatives to Spring that don't require so much configuration, even if it means forfeiting all of the benefits afforded by Spring.

But before you throw the baby out with the bathwater, you should know that there are several ways to simplify Spring configuration so that it isn't so XML-heavy.

In this presentation, I'll show you ways to cut back on Spring configuration while still achieving the same results. I'll discuss a few XML reducing ideas, such as custom configuration namespaces, and I'll also show you some XML-free options such

By Craig Walls

As a matter of good design and best practice, we all know we should divide our application code into logical layers or modules that can be developed independent of each other. But if modularization is a good practice to follow as we write our code, why do we package it all up into a monolithic WAR file for deployment?

Breaking an application down into several well-defined modules affords developers many advantages, including:

* Easier parallel development

* Improved testability

* Substitutability of functionality

* Isolation of updates

Both a de facto standard and a proper standard, OSGi offers lightweight modularity to Java. Spring Dynamic Modules for OSGi (Spring-DM) brings the power of Spring to OSGi, making it possible to create, deploy, and wire OSGi components together without mucking about in the OSGi API. Together, Spring-DM and OSGi enable assembly of applications from fine-grained modules (known as bundles) that can be developed, deployed, and updated independent of each other. This combinati

By Craig Walls

Spring Security (formerly known as Acegi Security) is a very powerful and flexible security framework for Java. Based on the Spring Framework, Spring Security provides declarative method and web level security including a wealth of options for meeting your application's specific security needs.

Despite Spring Security's great power and flexibility, it has historically been overly complex and difficult to configure. But all that has changed with the release of Spring Security 2. This new incarnation of Spring Security brings adds simplicity to power.

In this session, we'll explore the Spring Security framework and see how easy it is to use the new configuration elements and annotations to enable security in Java based applications.

By Craig Walls

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

Writing code is fun. But writing build code is...well...not so much fun.

How many times have you written the exact same "clean" target in Ant? How about "compile"? Or "war"? Let's face it: Virtually every Ant build.xml file ever written is pretty much the same as every other Ant build.xml file.

If writing build files is no fun, and if they're all clones of each other, then why do it?

In this session, I'll show you how to use Maven 2 to manage your build. Unlike Ant, Maven already knows how to compile, how to clean, and how to produce WAR files. You won't ever need to write (or cut-n-paste) that same build.xml file again.

By Craig Walls

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?

The contract between a web-service and its clients is often determined in a "contract-last" approach. That is, the service is designed and developed with little or no thought put into how a client will interact with it. Then WSDL is generated on-the-fly when the object is deployed. As a result, the contract is coupled to the service implementation's interface.

The promise of SOA is a network of loosely-coupled services that can be assembled into larger applications. But if the contract is coupled to the service implementation's interface, then the client is also indirectly coupled to that same interface. When the service implementation changes, the client must also change.

Thus we have th

By Scott Davis

There are wild-eyed radicals out there telling you that Java is dead, statically-typed languages are passe, and your skills are hopelessly out-of-date. Those extremists are the same ones who don't bat an eye at throwing out years of experience to learn a new language from scratch, pushing aside a familiar IDE for a new one, and deploying to a whole new set of production servers with little regard to legacy integration.

While this "burn the boats" approach to software development might sound exciting to some folks, it's giving your manager the cold shakes right now. What if I told you that there was a way that you could integrate seamlessly with your legacy Java code, continue to use your trusty IDE and stable production servers, and yet take advantage of many of the exciting new dynamic language features that those fanatics keep prattling on about? You'd probably say, "Groovy!" I would, too...

This talk focuses on integrating Groovy with your legacy Java codebase in a way that wouldn't raise an eyebrow in the most conservative of organizations. We'll look at the dramatic reduction in line of code you can achieve by simply flipping your POJOs (Plain Old Java Objects) to POGOs (Plain Old Groovy Objects). We'll talk about calling Java classes from Groovy, and calling Groovy classes from Java. We'll look at Groovyc, the integrated compiler that manages Groovy/Java dependencies without a hiccup.

Not once will I tell you to throw out the old in favor of the new. In each case, I'll show you how to integrate the new with the old. Don't throw out your Ant build scripts; mix in a bit of Gr

By Scott Davis

This talk focuses on the ways that Groovy can turn a traditional Java developer's world-view upside down. We'll start by talking about how you can thumb your nose at The Man by leaving out many of the main syntactic hallmarks of Java: semicolons, parentheses, return statements, type declarations (aka Duck-typing), and the ever-present try/catch block. Then we'll look at features like operator overloading and method pointers that Groovy welcomes back into the language with open arms.

The bulk of this session focuses on metaprogramming with Groovy. We'll add new methods to classes at runtime -- even if they were originally implemented in Java, and even if they were declared final. (Thanks, ExpandoMetaClass!) We'll call methods that don't exist and avoid the dreaded MethodNotFound Exception. (Thanks, invokeMethod!) We'll narrowly scope our metaprogramming shenanigans using Use blocks and Categories, and then cast our changes to the wind such that every instance of a class gets our added juice.

If you are happy taking the Blue Pill, this talk is not for you. You can continue using Groovy as a slimmed-down dialect of Java -- an 'After' picture to Java's 'Before'. If, howeve

By Scott Davis

Struts is the defacto web framework for Java web developers. It has been with us since 2001. Struts enjoys unprecedented success -- most surveys place its market share between 60% and 70%. It introduced a whole generation of web developers to the phrase 'MVC' (Model / View / Controller).

Grails 1.0 was released in 2008. It marries the modern features of Rails with the need for legacy support for Struts. Grails is inspired by Rails, but it is not a simple port of the project to Java. It takes the ideas of Rails, but expresses them in familiar Java libraries like Spring and Hibernate. It also leverages a new dynamic language for the JVM called Groovy.

In 2004, Ruby on Rails added some new phrases to the industry like 'scaffolding' and 'Convention over Configuration'. While these concepts helped ease the pain of traditional Struts development, they added a bit of a wrinkle: Rails wasn't implemented in Java, so the developer was forced to learn a completely new programming language. This had a ripple effect new IDEs, new web servers, new supporting libraries to learn, and on down the line. While greenfield development was a breeze in Rails, supporting legacy Java applications was relegated to high-level integration technologies like Web Services and shared databases. The views and business logic had to be rewritten from the ground up in the

By Scott Davis

How optimized is your website? YSlow, a FireFox/FireBug plugin, doesn't pull any punches. It gives any website an A, B, C, D, or F rating based on 14 individual analysis points. You'll be amazed (or depressed) at what YSlow thinks of your site. In this talk, we'll walk through these points step by step, learning what Yahoo! (the creator of this utility) does to keep its web properties running as quickly as possible.

These points are nicely summarized in "High Performance Web Sites", by Steve Souders (a companion book to the plugin). The analysis points that YSlow looks at are programming language, server, and web framework agnostic. The lessons learned here are really a deep look into HTTP, taking advantage of the native capabilities of the protocol -- making the Internet work for you.

By Scott Davis

JavaScript Object Notation is becoming a familiar delivery platform for Web 2.0 content. JSON gives you all of the flexibility of a RESTful web service without the hassle of trying to deal with deeply nested, complex XML in a language that is conspicuously lacking in native XML support. In this talk, we look at popular websites (like Yahoo!) that offer JSON output. We look at client-side JavaScript code that effortlessly consumes JSON in the browser. We even look at ways to easily generate JSON from Java Servlets (using JSON.org libraries) and the native support for JSON that Grails offers out of the box.

This talk also gives us the opportunity to brush up on our JavaScript, as well as look at clever ways that JSON can work around Cross-Site Scripting issues.

By Scott Davis

Yahoo! is a company that eats its own dog food. They open sourced the Ajax code that drives many of their own websites, including their eponymous homepage, Yahoo! Mail, and Yahoo! News. Come see first hand how the various pieces of the library work together as a seamless whole.

We'll look at some of the everyday useful widgets like the onscreen JavaScript logger (which effectively brings Log4J-style logging to JavaScript) and the calendar components. We'll see how event handling is managed in a cross-brower fashion. We'll look at tabbed interfaces, multi-level menus, and panels and dialog boxes that end up making your website look more like a OS-level desktop than a traditional webpage.

Grails certainly works with all of the major Ajax frameworks, but the easy bootstrapping of Grails combined with the power of YUI library makes for the quickest way to get started with a minimum of hassle. No previous Groovy or Grails experience is required, so come to learn a little about all of these. Any experience JEE developer will feel right at home since Grails uses Spring and Hibernate under the covers.

By Scott Davis

Based on the book GIS for Web Developers, this talk demonstrates how you can build your own Google Maps in-house using nothing but open source software. The Portland, Oregon Transit Authority recently migrated from a proprietary web mapping solution to the suite of 100% free and open source software discussed in this book. We look at Java-based clients, Java-based servers, and everything in between. We also discuss integrating free, public domain data from sources like the US Census Bureau and the USGS. If you're looking for real-world examples of AJAX in use, you'll find it here. If you're looking for real-world examples of web services in use, you'll find it here.

We start by exploring free datasets out there in the wild. They are stored in a myriad of file formats (some proprietary, some open) and projections. Free tools like GDAL and uDig make it easy to convert them and visualize them. Once the data is normalized, we store it in a PostgreSQL/PostGIS database. Not only does the database centralize the mapping data, it opens up quite a few interesting querying capabilities.

Serving up the data is the final piece of the puzzle. We look at web services based on the OGC (Open Geospatial Consortium) standards. We use Tomcat and the GeoServer WAR to expose our data via OGC interfaces. We look at a couple of Ajax-based mapping frameworks (MapBuilder and O

By Howard Lewis Ship

Part one (of two) covers the TestNG unit testing framework, and shows how it integrates with Selenium (for integration testing).

In part one of this two part session, we'll discuss the basics of unit testing and show how to use TestNG. We'll discuss how to use the tool, organize tests, and collect results, as well as integrate with IDEs, Ant and Maven. Lastly, we'll see advanced uses of TestNG combined with Selenium to automate integration testing within a test suite.

By Howard Lewis Ship

In part two (of two) we go in depth on EasyMock, the weird and wonderful tool for creating mock objects on the fly. We'll do a good bit of live coding as we examine how to use, tame and extend this powerful tool.

Unit testing with only gets you so far; even when you've refactored your code and hidden all your implementations behinds interfaces you are still stuck with the problem of testing the individual pieces. If you've hit this point and despaired, know that there are tools to help ... including the weird and wonderful EasyMock. We'll discuss unit testing in general, and how EasyMock is used to to generate mock objects, allowing you test each class in isolation. We'll be doing some live coding to show you step-by-step how to build up a unit test, interpret EasyMock's baffling error messages, and set yourself up for easy reuse of testing code.

By Howard Lewis Ship

Tapestry 5 is a complete rewrite of Tapestry from the ground up. It takes everything good about Tapestry and cranks the volume up to eleven, while removing the frustrating parts of using Tapestry. This session takes the wraps off this new and innovative technology, showing off important new features such as live class reloading (the ability to change your Java classes and continue using the application without interruption or redeployment), the simplified coding model, and the total lack of XML. This session is of interest to those already using Tapestry 4, and those new to Tapestry and ready to jump on the bandwagon.

Tapestry 5 really does take everything great about Tapestry and crank it up, all with the goal of making your job as a web developer easier. Being able to change your classes at will within a running application is just the tip of the iceberg; Tapestry 5 is designed to break down the barriers to developer productivity by simplifying every aspect of creating a web application.

Tapestry 4's base classes and abstract methods are all gone, replaced with pure POJOs and a handful of annotations. All the XML configuration of Tapestry has been removed as well. Tapestry 5 practices convention over configuration with a vengeance, introducing smart defaults and intelligent logic to let Tapestry do

By Howard Lewis Ship

Everyone likes the Gang of Four design patterns, but it's not always clear just how to make use of them in your day to day coding efforts. Hidden inside Tapestry 5 is an Inversion of Control (IoC) container that is structured around several common patterns (Chain of Command, Strategy, Decorator and Filter Chain will be covered). This isn't academic navel-gazing ... this is about leveraging the common patterns so that you can write code you can easily test, and about creating frameworks and toolkits that can be easily extended.

We'll see how Tapestry uses these patterns, and go from there into how you can apply the same techniques to your own projects, resulting in better, cleaner, more testable code.

This session also serves as an introduction to the Tapestry 5 IoC container.

By Brian Sam-Bodden

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.

Software development is expensive, when business rules are hard-coded in your application's source code, changes and additions to those rules translate to wasted time and money. Good object-oriented, component-based approaches can alleviate the burden of keeping up with changes in the business world but they still require that expert knowledge of the changes be passed from the decision makers to the business analysts and finally to programmers that need to implement these changes. Business Rule Engines and Business Rule Languages are based on the basic premise of separation of concerns by empowering business domain experts to express the rules of business in a way that it is directly usable

By Brian Sam-Bodden

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules application covering such topics as:

• Fine control and monitoring of a Working Memory session
• Using Decision Tables
• Advanced Rule Language Features
• Building Domain Specific Languages
• Managing your Rules

Many of the problems that we deal with in enterprises around the world are not usually related to the particular infrastructure, framework or programming language chosen but rather to the evolution and maintenance of the business logic that governs those systems. All knowledge in an enterprise is handed down stream until it arrives at the programmer's door. With Rule based systems we can empower those with the business but there is still a fair amount of work to get the ideal architecture for a particular problem in place.

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules ap

Prerequisite: Beginning Drools

By Brian Sam-Bodden

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.

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.

In this session learn the foundations of building Eclipse RCP applications, including SWT and JFace and we will use the concepts learned to create a professional looking Java application that can rival any .Net application.

By Brian Sam-Bodden

Mylyn is a task-focused toolkit for the Eclipse IDE that allows developers to focus on tasks in a way that they never been able to do before. Mylyn eliminates the constant context switching produced by typical ways IDEs are used. No more scrolling/browsing/searching/tagging/sending emails with progress updates... Mylyn provides a new way of working that allows you to focus on specific tasks by reducing information overload. Mylyn also provides a framework for integrating with the most commonly usage task tracking systems and version control systems. In this talk you'll learn how Mylyn can boost your productivity as a Java developer by letting you get the most out of your IDE.

Mylyn is a task-focused toolkit for the Eclipse IDE that allows developers to focus on tasks in a way that they never been able to do before. In this talk you'll learn how Mylyn can boost your productivity as a Java developer by letting you get the most out of your IDE.

By Brian Sam-Bodden

Learn how JRuby can bring simplicity to the complex and rich APIs available in the Java platform. In this session you'll learn how to use JRuby to tackle some common tasks in Java SE and Java EE as well as how to abstract and simplify complex APIs.

Learn how JRuby can bring simplicity to the complex and rich APIs available in the Java platform. In this session you'll learn how to use JRuby to tackle common tasks in Java SE and Java EE as well as how to abstract and simplify complex APIs. Learn the many new architectural choices that dynamic languages bring to the JVM. Get a taste of how JRuby can bridge the best of the rich and proven Java open source ecosystem and the flexibility of the next wave of innovation coming out of the dynamic languages camp.

By Brian Sam-Bodden

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.

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.

In this session you will learn:

- Understanding the O/R Impedance Mismatch

- Techniques of O/R Mapping

- Persistence Frameworks

By Brian Sam-Bodden

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.

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.

Some of the topics covered include:

- Handling and implementing inheritance

- Caching

- Profiling your queries

- Using filters for virtualization

- Custom SQL for performance

- Query caching

- ... and more