By Stuart Halloway
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.

We will take an existing application, and show you how to:

* download the source code
* build and run tests
* use rcov and code review to find some problem areas
* refactor some code
* create and submit a patch

Past "This Week in Refactoring" installments have contributed the following code to the community:

* http://trac.typosphere.org/ticket/1131

By Stuart Halloway
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.

I will give you ten poison pills that have been field-tested for their corrosive qualities:

* Wanting to succeed
* Sprinting
* Documenting source code
* Choosing the best tools
* Training developers
* Improving precision
* Applying the 80/20 rule
* Enjoying the process
* Keeping it simple
* Practicing noology

I personally promise that these pills, used as directed, will destroy any agile project.

No prior knowledge is necessary! These techniques are usable by anyone: developers, managers, stakeholders, and customers.

By Stuart Halloway
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.

JRuby provides a very powerful development platform: the expressiveness and beauty of the Ruby language, with full access to the huge and powerful world of Java libraries. In this talk you will learn to use JRuby as your glue to assemble applications from Java components.

We'll start with how to call Java from Ruby. You will see how to use the high-level API, which provides proxies for Java objects. You will also see how to use the low-level API, where you can get total control via Java reflection.

Next, we'll look at some things you might want to do with JRuby: testing Java code with Test::Unit, automating development processes with Rake, and wrapping useful Java APIs. Oh, and of course, we'll build a Ruby on Rails on Java application.

Finally, we will look at the architecture of JRuby. This is useful so that you can understand what capabilities (and limitations) JRuby has today, and how these are likely to change in the future.

By Alex Miller
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.

This session will look at the Terracotta architecture and technology and how it can be used in tandem with Hibernate to create a scalable clustered cache that maximizes the benefits of POJOs.

By Alex Miller
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.

In addition to covering the interfaces and implementations, we will also look at the backing data structures, iterator types, concurrency and performance concerns, and more.

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.0 and many more in Spring 2.5.
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 as using Java 5 annotations and scripting languages to configure Spring.

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 the classic versioning issue associated with web-services. When a service's contract changes, you can't realistically expect all of its clients to change right away.

One solution is to never change the service--design it up-front with everything it will ever need and never change it again. But this isn't very practical, as there's no way to predict what impact future requirements will have on the service. Yet another approach is to deploy multiple versions of the service. But this adds to the maintenance costs by having to juggle multiple versions.

Another option that is gaining a lot of attention lately is the notion of contract-first web-services. The contract-first approach is message-centric. Instead of treating web-services as "RPC with angle-brackets", contract-first treats web-services as message receivers. In doing so, a web-service can be written in such a way as to decouple its from contract from its implementation.

In this session, we'll take a look at Spring-WS, a Spring-based web-service framework for building contract-first web-services.

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 David Bock
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.


In this presentation we will analyze what makes a 'good' metric, why some metrics are 'bad', and how you can use them to make meaningful measurements of your projects. We will look at several methods for gathering metrics too, including some open source tools you can put to use immediately.

By David Bock
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.

This presenter spent 9 years developing applications for the U.S. State Department that have been deployed in dozens of countries and languages. While some aspects of internationalization and localization are trivial, there are plenty of issues that are not. If you have an application that you expect to localize into other locales, there will be information here that is invaluable to you. This talk is entertaining for the war-stories alone! No other no-fluff presentation will feature pictures of the presenter waiting in line behind a herd of sheep to cross a pontoon bridge into Bosnia.

By David Bock
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.

Introducing change into a large organization can be difficult, even when everyone is in agreement. By starting with 'the quick win' and fixing some real pain in your organization, you can begin to get people moving in the right direction. In this talk we will look at the kinds of quick process wins that are possible, and how to introduce new ideas into a large organization.

By David Bock
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.

This talk will talk about everything from build processes, teamwork, and project structure through versioning, release plans, upgrde strategies, package dependencies, and more. Using real-world scenarios from two projects with 12-15 people working together over a 5-year time span, this presentation will offer advice based on multiple successful deliveries of real software.

By David Hussman
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.

The session will focus on finding the people who are best suited to create and communicate agile requirements. We will examine how to ensure agility for user stories, use cases, and several other common forms of requirements. Without regard to the document type, we will show how to smoke out what needs to be captured in written form when, challenging the age old notion that more detail in requirements produces better software.

By David Hussman
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".

From using markers and post it notes to go faster tools, this session will examine ways to get agile going in various situations (e.g. small projects, large projects, or distributed projects). A variety of techniques and tools will be shown and discussed along with the pros and cons of each. Most importantly, you will come away with a variety of ways to start planning and tracking agile projects, so you can choose a path which fits best within your company.

By David Hussman
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.

What is executable documentation? Simply put, instead of adding more details to requirements, capture the desired system behavior in acceptance testing tools which are accessible to the entire project community. The session will focus on FIT, but it may include other tools for creating ED. History has shown me that ED - requirements that have two states (green and red) - helps project communities consistently create better software, faster!

By David Hussman
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.

We will start with things to do to prepare for the first iteration: assessments, project chartering, setting up a lab, iteration 0 and creating your first backlog. From there we will move into coaching practices like fostering discussions, facilitating retrospectives, social radiators, developer manifestos, talking in tests, and more. These are the techniques that will help you lead and successfully guide a newly forming agile community.

By David Hussman
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.

We will walk through some basics which need to be in place and then we will move on to advance topics like maintaining a living backlog, adapting to change, growing meaningful metrics, radiating information, working with project members, anti-coaching and more. We will also discuss a collection of monitors (spontaneous pairing, ?us? and ?them?, presence of pride, emergence of leaders) used by working coaches to determine which practices to use.

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

By Jeff Brown
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.

This session is targeted to demonstrate the power of Groovy and help Java developers understand how to leverage that power in their enterprise applications. Topics
include:

- Everything Is An Object
- GStrings
- Closures
- Collections
- Groovy Builders
- Groovy Beans
- Categories
- Ranges
- Java Integration

By Jeff Brown
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.

This session will cover in detail a number of advanced metaprogramming concepts in Groovy. The discussion will cover using dynamic method interception, custom meta-class implementations and Groovy's Metaobject-Protocol (MP) to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

By Jeff Brown
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.

This session will cover using Groovy to test Groovy and Java code, web applications and desktop applications. The session will include a lot of live code examples demonstrating the power of Groovy in testing.

By Jeff Brown
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.

This session will demonstrate how easy it is to get a simple application up and running with almost no effort and then evolve that application by adding features to really show off the power of the Grails
framework. Topics include:

- Grails Quick Start
- The Grails Command Line Tools
- GORM and Hibernate
- Groovy Server Pages (GSP)
- Spring Integration
- Unit Testing
- Functional Testing

By Jeff Brown
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.

This session will cover all of these topics to demonstrate how powerful the Grails framework is and show how little effort it takes to build not just a simple toy application but also to build real enterprise web apps.

By Ken Sipe
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?



This talk will walk through the underlying details of memory management in the JVM with a focus on VM flags available to help configure the VM. However we can't configure the VM without a detailed understanding of what is going on inside the VM. We'll focus on tools available for analyzing the memory in a running VM. Two actual client case examples will be presented. We'll discuss the differences between the two cases and why the end configurations were quite different.

By Ken Sipe
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.



This session covers JMX 1.2 specification, system monitoring, management needs, and the creation of agents which dynamically manage resources based on monitoring. We cover many of the new features of the Remote JMX access.

The JMX support in Spring provides features to easily and transparently integrate Spring applications into a JMX infrastructure. Some of the tougher tasks of JMX develop are made easy with Spring. We'll look at automatic
ObjectNames, automatic registration and remote connector proxies as we review Spring's JMX features.

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

We start with a discussion of why JSF is significant and explain how it lays the foundation for a range of new products. We then look at the IDE offerings from major industry players, such as Sun, IBM, and Oracle. Next, we examine the products from smaller vendors and open source organizations, such as component suites and additional toolkits and frameworks, examining the specific features and benefits that these products provide. Finally, we look at other potential product opportunities and examine ways to get involved.

Prerequisite: Basic familiarity with web application development in Java.

By Kito Mann
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.



JSF allows you to build AJAX applications without worrying about the complexities of JavaScript and DHTML. However, many different approaches for using AJAX with JSF have emerged. This session looks at these different approaches, the pros and cons, and provides key insight into JSF's future as an AJAX web development platform.

By Kito Mann
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.

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.

Specific tools such as Apache MyFaces Orchestra and Spring WebFlow will be discussed. At the end of this session, developers will understand how to build a full-stack JavaServer Faces/Spring/Hibernate or JPA application with features similar to those of JBoss Seam.

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

GWT makes writing web applications similar to Swing applications. It dramatically reduces the need to understand HTML and JavaScript, while retaining the use of CSS for formatting. We'll cover the advantages of using GWT over other web app. frameworks and walk through the steps to create a new application. An application will be written before your eyes to demonstrate how easy it is.

By Matt Secoske
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.

We will look at how Groovy handles things differently from Java:
- General code style
- Collections
- Static vs Dynamic Typing
- Accessors
- Testing

By Matt Secoske
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.

Such as:
- Symmetric and Asymmetric encryption algorithms
- Message digests, digital signatures
- Public Key Cryptography
- Elliptical Curve Cryptography
- Secure protocols (SSL, SSH, SFTP)

By Matt Secoske
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.

Specific topics covered:

What is a DSL?
When should you use one?
Groovy's features for building DSLs
Examples

By Michael Nygard
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

The bad news: applications are more complex and error-prone than ever. Site development projects are really enterprise application integration projects in disguise. SOA portends far-flung interdependencies among unreliable services. Failures will spread wider and wider, reaching across your company and even crossing boundaries between companies.

How do monumentally costly failures begin, develop, and spread?

Can they be averted?

Once you hit Release 1.0, your system will be living in the real world. It has to survive everything the messy, noisy real world can throw at it: from flash mobs to Slashdot. Once the public starts beating on your system, it has to survive--without you.

Did you know that just having your database behind a firewall can bring down your system? Ill show you that and many other risks to your system. You will learn the biggest risks to your system and how to counter them with stability design patterns. We'll talk about the best way to define the term "availability" and why the textbooks get it all wrong.

In this session, you will learn why the path to success begins with a failure-oriented mindset. I'll talk about numerous antipatterns that have caused and accelerated millions of dollars worth of system failures. I'll share some of my scars and war stories with you (don't worry, they're all suitable for polite company) in the hopes that you can avoid some of these costly disasters.

By Michael Nygard
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


In part 1, we looked at common sources of system failure: those commonly created structures that exacerbate problems.

Now, we'll take on Stability Patterns that not only stop the antipatterns, but also add resilience to your system. Apply your new failure-oriented mindset to unchain yourself from the pager and save your company from embarrassing--and costly--disasters.

These patterns combat entire classes of failure modes, making your system robust against even unforeseen problems.

Books on design and architecture only tell you how to meet functional requirements. They help your software pass Quality Assurance. But painful experience has shown that "feature complete" is not even close to "production ready." After this talk, you'll be prepared to use your failure-oriented mindset to make your system a success.

By Michael Nygard
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.

If you don't want to wear a pager for the rest of your life, this session is for you.

We will explore the most critical foundations for success in Operations: transparency, control, deployments, and configuration.

Along the way, we'll see some of the organizational dysfunction that prevents smooth, successful operations. You'll learn what you can do today to avoid these dysfunctions, even if you've inherited a legacy of distrust between Development and Operations.

By Scott Delap
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.


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.

How can a RCP Framework help my application?
Menus
Events
Jobs
etc..
Introducing Eclipse RCP
The base of the Eclipse IDE
Actively Developed
Leveraged By Many Projects
...
Eclipse RCP Services
Plugins
Core based on OSGi
Extensions
Menus/Toolbars/Actions
Jobs
View Framework
Tools Support
Plugin Editors
Product Definition
...
Deployment
One Click Webstart Deployment
Support Multiple Platforms

By Scott Delap
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.


The first generation of web applications sacrificed usability and function for ease of deployment. Recently the industry has shifted back to richer user interfaces written in Ajax, Flash, and Java. Many business applications have requirements such as offline access, desktop integration, and UI customizations that make using Ajax and Flash difficult to near impossible. For such applications rich client architectures featuring online deployment and web enabled client/server communications provide the easiest path to development success. Eclipse's Rich Client Platform provides organizations a valuable jumpstart in the creation of such applications. Eclipse RCP allows enterprise applications to reclaim the powerful user interface paradigms that were lost with the emergence of thin clients, while retaining the benefits of server-side scalability, security, and reliability. However, a number of the core functions of such business applications are not handled transparently by Eclipse RCP out of the box.

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.

By Ted Neward
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?

In this talk, we'll look at the various things that can occur in an enterprise Java app (from the smallest web site to the largest multi-resource environment) to make your Java apps perform and scale less well than they should, and how you can work to correct them. We'll examine a variety of broad concepts to apply in architecture and design, and examine what factors make an enterprise application slow, then use a variety of tools to figure out how to remedy them.

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

Come hear why this is, and what practicing programmers need to do in order to ride the forefront--instead of the trailing edge--of this new wave in computer science.

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

For an audience comfortable with some prior Java experience, preferably familiar with Java5.

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 Tom Wheeler
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.



This session will provide a solid introduction to the Java Content Repository, including:

- The Java Content Repository API
- History of JSR-170 and future directions
- Comparison to other data management techniques
- Discussion of available implementations, with a focus on open source versions
- A practical example using JCR in lieu of a traditional RDBMS