Session Schedule

By Ben Galbraith

For many of us, XML has become a ubiquitous presence in application development, whether parsing, validating, or manipulating it. For many of us, all that XML is coupled with pain, in the form of tedious APIs (like, say, the W3C DOM API) and confusing technologies (oh, I don't know, W3C XML Schema?).

In this session, I share the following tips for making the XML in our lives a little easier to deal with: - Use StAX instead of SAX - Use StAX to create XML - Use JDOM instead of W3C DOM - Use XPath to select XML - Use Jaxen to enable XPath over custom trees - Use RELAX NG instead of DTD or WXS - Use Trang when DTD/WXS output is required - Use Sun's RELAX NG Converter when WXS input is required - Consider RELAX NG's compact syntax - Use Schematron to extend schema languages - Consider XML namespaces for versioning - Ignore unknown namespaces

By Ben Galbraith

Too often, Swing applications are slow, ugly, and hard-to-maintain. It turns out that it doesn't have to be this way. Swing can be used to create highly-responsive, beautiful applications that are very maintainable. If this isn't consistent with your own experience, don't feel bad; its not very obvious how to make Swing sing.

In this session, I explore three topics that lead to much better Swing applications: Proper Swing threading High-quality third-party Swing look-and-feels Good practices for coding Swing applications In the threading portion of the session, I explain Swing's event handling architecture and its implications for Swing applications. Understanding this topic is crucial to creating highly-responsive Swing apps. I demonstrate how to use this knowledge in the form of many live-coded examples, and I show how frameworks like SwingWorker and FoxTrot can make this easier. Java's default look-and-feel, Metal, is awful (and in my opinion, the "Ocean" theme in JDK 5.0 doesn't do enough to improve it

By Ben Galbraith

Are you spending more time plumbing your Swing applications than solving business problems? Has your Swing application grown out of control? This session is for you.

In the first part of the presentation, I analyze the architectural problems that plague many Swing applications and present architectures that overcome these problems. These architectures are presented in terms of principles along with a reference implementation. You can therefore either adapt the principles to meet the needs of your existing applications, or incorporate the specific ideas of the reference implementation into your new projects. Fortunately, there are some existing frameworks that have done some of the architectural work already. I present some of these frameworks in the rest of the presentation.

By Ben Galbraith

The Eclipse project's SWT GUI toolkit provides one of the only viable alternatives to Swing for creating so-called rich client applications in Java. Whereas Swing paints its own widgets and has distinguished itself with a complex (and often obtuse) API, SWT relies on the host operating system for widget rendering and sports a simple, clean API. If your goal is to create a Java application that "looks" like a normal Windows application (or OS X, or Linux), SWT will revolutionize your world. In this session, I introduce SWT from the ground up. I start at a high-level, but quickly move into the details of SWT's API. By the presentation's end, attendees will have a solid understanding of SWT.

The Eclipse project's SWT GUI toolkit provides one of the only viable alternatives to Swing for creating so-called rich client applications in Java. Whereas Swing paints its own widgets and has distinguished itself with a complex (and often obtuse) API, SWT relies on the host operating system for widget rendering and sports a simple, clean API. If your goal is to create a Java application that "looks" like a normal Windows application (or OS X, or Linux), SWT will revolutionize your world. In this session, I introduce SWT from the ground up. I start at a high-level, but quickly move into the details of SWT's API. By the presentation's end, attendees will have a solid understanding of SWT.

By Ben Galbraith

This session picks up where SWT Fundamentals leaves off. Among the advanced topics I discuss are creating custom SWT widgets and exploring tight native integration. I combine another compelling topic with the advanced SWT material: JFace. SWT is a more akin to AWT than Swing; its concerned more with wrapping native functionality than providing any high-level abstractions. JFace is an API on top of SWT that provides such abstractions. The combination of SWT and JFace is comparable to Swing. My coverage of JFace includes an introduction to several of its frameworks, such as the Viewer and Window frameworks, along with many examples. Learning JFace will enable you to write complex SWT applications much faster.

This session picks up where SWT Fundamentals leaves off. Among the advanced topics I discuss are creating custom SWT widgets and exploring tight native integration. I combine another compelling topic with the advanced SWT material: JFace. SWT is a more akin to AWT than Swing; its concerned more with wrapping native functionality than providing any high-level abstractions. JFace is an API on top of SWT that provides such abstractions. The combination of SWT and JFace is comparable to Swing. My coverage of JFace includes an introduction to several of its frameworks, such as the Viewer and Window frameworks, along with many examples. Learning JFace will enable you to write complex SWT applicati

By Ben Galbraith

You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years, XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally interesting. Things get really exciting when XML is dynamically transformed into other formats. In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML -- a sort of open-source version of the popular Macromedia Flash format. SVG files can be converted into beautiful, completely scalable -- and interactive - - images.

You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years, XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally interesting. Things get really exciting when XML is dynamically transformed into other formats. In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML -- a sort of open-source

By Ben Galbraith

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

Experienced web developer Dion Almaer (editor of TheServerSide.com) and noted Java desktop expert Ben Galbraith will describe and demonstrate these new techniques, including how to adapt modern web frameworks such as JSF and Tapestry to ease both the creation and maintenance of these types of applications.

By David Geary

Okay, so you know a little about JSF. You understand managed beans, action outcomes and how to attach standard JSF validators to components in a JSP page.

But there is a great deal of functionality that the average web application supports that JSF doesn't provide out of the box. For example, wouldn't you like to have JSF automatically place asteriks in front of labels for required fields? You are going to implement client-side validation, which JSF does not support out of the box, aren't you? Of course, you're going to test your application, right? And don't forget to trap unauthorized use of the back button.

How do you do all of that stuff in a JSF application? If those are the kinds of questions that keep you up at night, then this session is for you. We will explore the outer reaches of JSF development to illustrate how you can bend your next JSF application to your will.

By David Geary

JavaServer Faces is a well designed user interface framework, but it lacks a number of features you might otherwise expect out of the box; for example, JSF does not explicitly provide support for client-side validation.

So, from the folks that brought you Struts, comes Shale, a collection of useful enhancements to JSF. A top-level Apache Software Foundation project, Shale adds some really cool features to vanilla JSF, including:

Web flow: script dialog flow Remote Method Calls: easily call JavaBean methods from JavaScript Tapestry-like views: code views in pure HTML Use Apache Commons Validator validators on the client or server, or both JSF testing framework: mocks for easy JSF testing

There's a lot of cool stuff in Shale that makes JSF a much more compelling proposition. Come see what it's all about.

This is a code-intensive, fast-paced look at Apache Shale. Forty-plus slides and five demos makes for an action packed session that illustrates the cool features that Shale provides.

By David Geary

User interfaces are usually the most turbulent aspect of an application during development. Constant tinkering with the UI means constant changes to your code, so as a UI developer, you want to minimize the scope and effects of those code changes.

Open-source Java provides two powerful software packages that help you manage UI complexity: Tiles and Sitemesh. Tiles composes webpages from discrete regions of your user interface known as tiles. A tile contains a JSP page for layout and one or more JSP pages for content. Sitemesh decorates webpages with decorators that can be associated with URL patterns. Once you set up your decorators, you can decorate pages that match a decorator's URL pattern.

Come see how to use Tiles and Sitemesh with a guided tour from the inventor of Tiles, who has recently become a Sitemesh believer.

By Justin Gehtland

For centuries people have used crypto to build (and break) secure systems. Computers have only raised the pitch of conflict, providing enormous cryptographic power at commodity prices. Most programmers do not write their own crypto libraries, instead relying on the services of an operating system or virtual machine. But even with all this support, building secure systems is a daunting task.

This talk will cover three things all programmers need to know: 1. the basic tools of computer crypto 2. the programmatic APIs to these tools 3. common programming mistakes that can undermine otherwise secure systems You will learn the basics of hashing, message digests, public key encryption, symmetric key encryption, certificates, and key management. With each, you will see programmatic examples, with advice for correct usage.

By Justin Gehtland

Following directly on Cryptography for Programmers, Applied Crypto shows how the cryptographic primitives introduced in the previous session are combined into the identity, confidentiality and authorization systems we use today. We'll take a deep look at certificates, then examine their use in the Secure Socket Layer (SSL) protocol. From there, we'll examine the two competing dreams of distributed identity: PKI and Kerberos.

By the end of this session, attendees will understand the landscape of cryptographic identity systems and the benefits and costs of each. All along the way, we'll look at real code samples to demonstrate the principles, and as an added bonus, we'll finish with an examination of alternative trust models for the truly paranoid.

By Justin Gehtland

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

In this session, we'll explore: • configuring ACEGI to authorize against an in-memory user list, a database, and a JAAS login module • page level authorization • method level authorization • instance level authorization • forcing HTTPS connections to secured sites • impersonation using the RunAsManager

By Justin Gehtland

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

This talk will introduce you to the Spring web application framework. You'll find out about the Controller hierarchy, and how the different kinds of Controllers allow for a more manageable logic tier. We'll look at validation and exception handling, configuration, URL mapping and CommandControllers (Spring's answer to ActionForms). Finally, we'll look at Spring's integration with another powerful web framework, Tapestry.

By Justin Gehtland

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

This session will examine these specifications, including: • WS-Security • WS-Policy - for sharing enforcement and encryption strategies • WS-Privacy - for agreeing on privacy policy for service usage • WS-Encryption - for encrypting or signing all or part of a message • WS-Trust - for creating a single-sign-on solution • WS-Federation - works with WS-Trust These specifications, plus others like WS-Addressing and WS-Notification, provide a platform for communicating security intent across multiple network layers and many platforms. Of course, these specifications only define modifications to the messagapplication author. We will demonstate these capabilities using the Axis toolkit a

By Justin Gehtland

O/RM (Object/Relational Mapping) seeks to eliminate repetitive or tedious work enabling the CRUD (create, read, update, delete) that underlies most applications. Hibernate is a popular, open-source O/RM tool that uses reflection (instead of code generation, like EJB, or bytecode injection, like JDO) to manage your persistence layer. This session will introduce you to Hibernate. After an overview of common usage scenarios, including web and enterprise applications, we'll examine the basics of getting Hibernate running. We'll cover the mapping file format and syntax, including common relational mapping structures. Then, we'll examine the Hibernate API for interacting with the framework. Finally, we'll cover the common architectural decisions you'll have to make as you include this (or any other) O/RM framework.

O/RM (Object/Relational Mapping) seeks to eliminate repetitive or tedious work enabling the CRUD (create, read, update, delete) that underlies most applications. Hibernate is a popular, open-source O/RM tool that uses reflection (instead of code generation, like EJB, or bytecode injection, like JDO) to manage your persistence layer. This session will introduce you to Hibernate. After an overview of common usage scenarios, including web and enterprise applications, we'll examine the basics of getting Hibernate running. We'll cover the mapping file format and syntax, including common relational mapping structures. Then, we'll examine the Hibernate API for interacting with the framework. Finall

By Justin Gehtland

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

This session will show advanced techniques for tuning performance, including: • advanced collection mapping strategies • lazy loading • cascading update management • lifecycle management • Hibernate's interceptor layer In addition, we'll examine the security considerations when using Hibernate. Often, single-credential data access isn't enough for sensitive data. We'll walk through using per-user credentials for data access, logging security information about and through Hibernate, and accessing data sources through secure application servers.

By Stuart Halloway

Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.

Java's support for threads is broad and deep. From the early days of the platform, programmers have used threads, synchronized blocks, and monitors to build safe multi-threaded applications. Java 1.5's new concurrency utilities greatly reduce the need to use these primitives directly. Now, Java provides a set of lock classes and task scheduling tools that provide much more leverage in writing real applications. We'll explore java.util.concurrent, and also see how the Java Memory Model has been corrected in 1.5. Most of the advantages of java.util.concurrent can also be had in previous version of Java. We'll discuss Doug Lea's concurrency utilities and the backport of java.util.concurrent to

By Stuart Halloway

JUnit is great. Jython and JRuby are even better. Unit testing libraries look the same everywhere, so why not use the one that lets you get your job done faster?

Unit testing has taken the world by storm. Almost every major language has a JUnit-like library. And here's the good news: These libraries are so similar that once you learn one, you can use any of them. Given that many languages interoperate directly with Java, you aren't limited to JUnit. You can pick the library that provides the best language level support for writing concise, easily maintainable unit tests. Circa late 2005, there are good arguments for the unittest module in Jython, and Test::Unit in JRuby. The talk is divided into three parts: A crash introduction to unit testing Java code. We'll cover test-driven development, test cases, assertions, fixtures, and test suites. We'l

By Stuart Halloway

Reflection is writing code that manipulates itself. Well-written reflective code automates a broad class of repetitive, error-prone programming tasks. Poorly-written reflective code obfuscates programs and destroys the benefits of the type system. We'll focus on the former.

REFLECTIVE TASKS COVERED IN THIS TALK Discovering class members Dynamically accessing fields, methods, and constructors Bypassing the Java language protection modifiers Converting between objects, XML, and relational data Generating new classes at runtime Intercepting method calls and simple aspects The reflection security model

By Stuart Halloway

The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

You will learn the core APIs: SecurityManager, AccessController, Permissions and Policy JAAS Subjects, Principals, and LoginModules You will then see how to invoke these APIs in real application scenarios. You will learn how to: Partition your applications to safely invoke downloaded code Read and write Java policy files Extend the architecture with custom permissions Provide secure services through PrivilegedActions Use JAAS to authenticate and authorize users

By Jason Hunter

Java's new Metadata facility introduced in J2SE 5.0 defines a way to attach decorations to classes, fields, methods, and even packages that can be extracted by the compiler or runtime tools to provide advanced functionality. Think of metadata as an extended @deprecated flag, or think of XDoclet++. In this tutorial session you'll learn how Metadata fits in the Java platform (and how it compares to the C# platform). We'll cover how to use the metadata attributes provided in the core J2SE libraries and how to write your own. We'll also show a bit of what's coming in JSR-181, tasked to define standard metadata attributes for web services.

Attendees should be skilled Java programmers ready to see what's possible in the latest release and learn to make the most of it.

By Jason Hunter

There are many interesting and useful algorithms that people just don't remember or never learned. The Boyer-Moore string search algorithm is one prime example. The randomized skip list is another. Both solve common problems with wonderful flair and finesse -- and performance-wise they blow the pants off brute force solutions. This session covers these two algorithms plus several others. It's like your college algorithms course but with a practical bent and absolutely zero proofs. Extra bonus: The Google PageRank algorithm.

This session covers these two algorithms plus several others. It's like your college algorithms course but with a practical bent and absolutely zero proofs. Extra bonus: The Google PageRank algorithm.

By Jason Hunter

XQuery is a new language from the W3C that lets you query and manipulate XML -- or anything that can be represented as XML, such as relational databases. As a Java developer -- especially a server-side Java developer -- XQuery is key to searching and manipulating large XML repositories or performing any XML-centric task.

This talk introduces XQuery. I'll explain the XQuery language; I'll show how to call XQuery from Java; and as the creator of JDOM, I'll also explain when to use XQuery instead of JDOM, and when to use both.

Attendees should have an interest or need in managing large sets of XML, but need not have any past experience with XQuery. After the session, attendees will be able to program XQuery and know which implementations to trust.

By Jason Hunter

The new Java 5 release introduces a number of significant Java language enhancements: generics, typesafe enums, autoboxing, an enhanced "for" loop, a static import facility, and a general-purpose metadata facility. This talk gives an overview of the changes and helps you understand what all the funny new syntax means.

The main new language topics covered: Generics, also called "parameterized types", which let you specify the type of objects used in a collection, among many other things. Autoboxing, that lets you implicitly convert from primitives to reference types, and vice-versa. An Enhanced For Loop, that lets you iterate over arrays or collections with half the code as before. Typesafe Enums, to create object-oriented, extensible enumerated values. Static Imports, to put into scope static methods and fields. Varargs, that allows methods to accept an arbitrary number of parameters. A Metadata Facility, allowing decoration to classes and methods for later tool consumption. Covered in more depth in th

By Jason Hunter

Web Caching is very important for high traffic, high performance web site but few people know all the professional-level strategies. In this talk I'll share some of the tricks of the trade, including advanced tips from Yahoo's Mike Radwin.

We'll start with the basics: using client-side caches, conditional get, and proxies. Then we'll talk about more advanced features: how best to handle personalized content, setting up an image caching server, using a cookie-free domain for static content, and using randomization in URLs for accurate hit metering or sensitive content.

Attendees should have experience or interest in how the web works and in cajoling the web into doing their bidding.

By Ramnivas Laddad

J2EE has become the main new platform for enterprise application deployment. Good performance is an important business requirement. Supporting this requirement needs application profiling during the development phases and performance monitoring after application deployment. Come to this session to understand challenges and choices in monitoring J2EE applications.

Performance monitoring solutions must work under constraints imposed by the environment. Further, they must balance conflicting requirements such as overhead vs. richness of information. All of these need careful understanding of both requirements and solutions as well as the costs of any tradeoff decisions. This session presents various tools and techniques available for monitoring J2EE applications. We will consider requirements of performance monitoring solutions in different scenarios. We will also discuss underlying enabling technologies such as Java Virtual Machine Profiling Interface (JVMPI), Java Virtual Machine Tool Interface (JVMTI), JFluid, JMX, design patterns, and aspect-orien

By Ramnivas Laddad

Aspect Oriented Programming (AOP) enables modularizing implementation of crosscutting concerns that abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concerns in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to system requirement changes. Come to this session and learn all about how AOP can help you simplify developing complex systems.

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with the most commonly used IDEs, which makes the Java developer more productive. This session is targeted at the developer with no or little familiarity with AOP and AspectJ. It will introduce AOP’s concepts and the AspectJ programming language, along with many examples and live coding to solidify the concepts learned. After attending the session, you will have a clear idea about AOP's value and

By Ramnivas Laddad

Aspect Oriented Programming (AOP) enables modularizing implementation of crosscutting concerns that abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concerns in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to system requirement changes. Come to this session and learn all about how AOP can help you simplify developing complex systems.

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with the most commonly used IDEs, which makes the Java developer more productive. This session is targeted at the developer with no or little familiarity with AOP and AspectJ. It will introduce AOP’s concepts and the AspectJ programming language, along with many examples and live coding to solidify the concepts learned. After attending the session, you will have a clear idea about AOP's value and

By Ramnivas Laddad

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

Aspect-oriented refactoring provides means beyond conventional refactoring techniques. While steps in conventional refactoring modularize code to a certain point, the use of AOP squeezes out the code that cannot be further refactored. Aspect-oriented refactoring offers substantial improvement to the code in a variety of situations: exception handling policies, local contract enforcements, resource management and optimization schemes, concurrency control, worker object creation, and so forth. This presentation will examine fundamentals of aspect-oriented refactoring, a few common patterns, and a few examples in J2EE space. The presentation features live coding to illustrate the ideas learne

By Ramnivas Laddad

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

Implementing design patterns using AOP offers multiple benefits. First, like other applications of AOP, it modularizes the implementation of the design patterns. The modularization localizes any changes, such as introducing optimization and switching from one concurrency control scheme to another without system-wide re-implementation. Second, new design patterns can be introduced in systems without invasive changes. Third, use of AOP to implement design patterns results in reusable code components. In effect, AOP transforms the reusable concepts in design patterns into reusable code. Further, use of AOP does not modify the intent and philosophy of the target design patterns, thus preserving

By Ted Neward

Security's become a hot topic among enterprise developers in recent years, but to many developers, security is still the white elephant in the middle of the room. Discussions about security usually begin with, "Uh, we'll worry about that later", or, "Start with two really large prime numbers.....". Security isn't as hard as developers make it out to be, but it is something that developers need to face and recognize.

In this talk, we'll extract the 10 Items on Security from Effective Enterprise Java and talk about them, giving developers the basic heads-up they need to have when building enterprise systems in Java.

By Ted Neward

There's a set of fallacies that every enterprise developer has fallen for at some point in their enterprise development lives, and unless they've come to realize it early enough, all cause big trouble and painful learning experiences in the long run.

In this talk, we'll go over the Enterprise Fallacies, discuss why they're so insidious and easy to fall into, and how developers can go about making sure they avoid them in the future. Discussions will be relative to both .NET and Java, as well as the emerging Web services stack, as the Fallacies know no technical boundaries.

By Ted Neward

Bring all of your enterprise Java questions to this open forum discussion hosted by the author of “Effective Enterprise Java”, Ted Neward.

This session will be a great opportunity to listen & participate in a discussion on all things relating to enterprise Java.

By Venkat Subramaniam

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

Topics: • Design ideas • Types of Tests • Identifying tasks • Fulfilling tasks • Order of tests • Handling success and failure • Layering of system • Test cases and Test Suite • Using JUnit • Quality of tests • Where to run and how often? Benefits: • Learn how to write unit tests • Realize its benefits • See how it affects your design • See how you can develop robust system • It will change the way you write code

By Venkat Subramaniam

Is your code object-oriented? Developing with objects involves more than using languages like Java, C#, C++ or Smalltalk for that matter. From time to time, the OO paradigm stumps even expert developers. Agile programming becomes a mere act of hack if we code without knowing the OO principles. What are these principles – the ones that influence your design? In this presentation the speaker will present some of the challenges that are fundamental in nature. Then he will present OO Design principles and good practices for prudent development of OO code.

Topics: • Metrics of design • Good design vs. bad design • Perils of design • Principles for OO Design • Examples that illustrate the principles Benefits: • Learn principles that lead to better design • Learn fundamentals that will change the way you will code • Gain insight into the design tools needed for agile development • Helps improve the quality of your system • Better your design skills

By Venkat Subramaniam

Java introduced Generics in the 1.5 version (Java 5). What are the capabilities of Generics? How do you use it? Are there some gotchas in using it? In this example driven presentation, we will start at the basics of generics and look at its capabilities. We will then look at some of the under the hood details on generics implementation. We will then delve into the details of some of the changes to Java libraries to accommodate generics. Finally we will take a look at some restrictions and pitfalls that we need to be familiar with when it comes to practical and prudent use of generics.

Topics: • Need for Generics • Generics in Java • Bounded Parameters • Wildcard • Restrictions • Generics Implementation • Effect of Erasure • Java libraries changes • Pitfalls and pragmatics Benefits: • Know your generics • See how to create your own generics • Understand issues with converting to genetics • Learn the limitations • Attain the wisdom • Decide if this if for your project

By Eitan Suez

Classes will often bear various states. Examples include a user who may be "logged in" or "logged out," a bill that is "open" or "paid," or potentially a more complex situation where an object obeys a set of complex rules that determines which of a number of possible states that object is in. The Gang of Four gave us the State Pattern, a fairly straight-forward mechanism for developers to model and implement the behaviour of stateful objects. The State Pattern is only the beginning of the story. Robert Martin developed the State Machine Compiler and has taken the job of developing and maintaining stateful systems to a new level. Today, SMC is a well-maintained open source project hosted on sourceforge.net. Come learn about SMC, a fundamental tool for implementing stateful classes and systems that every software developer should have in his toolchest.

Session Goals: Developers today are faced with increasing pressure to deliver robust software with increasing levels of sophistication and features. The goal of this session is to introduce a software consruction tool that cleanly separates the concern of managing object state transitions from the rest of a software system. The end result is an application that takes less time to code, is easier to maintain, and that can dramatically reduce the complexity (and consequently the increases the quality) of the implementation. Prerequisites: Basic understanding of the Java programming language and of object-oriented programming and design. Familiarity with "Gang Of Four" Design Patterns. Ses

By Eitan Suez

Today, the Cascading Style Sheets (CSS) specification is well supported by the major browsers (Mozilla, Safari, IE). CSS has become a practical tool for web content publishers that has helped turn heavy, buggy, and hard-to-maintain web sites into lean, clean, and stylish ones. CSS is sometimes stereotyped as a technology geared for graphic designers and artists. I beg to differ: I see CSS as a refactoring tool for content publishers and one that encourages content to become more strongly semantic. Come see a developer's perspective on CSS and how it can be applied to refactor your web content.

Session Goals: To "grok" CSS. To dispell the myth that CSS is not a tool for software developers. To learn to wield CSS to produce superior web user interfaces. Prerequisites: Prior experience with web technologies (specifically HTML) is assumed. Audience is assumed to have a programming background. Session Rating: Intermediate Category: Languages

By Eitan Suez

Join Eitan in this hands-on session on Naked Objects. This session uses the "learning by doing" approach to learning an API or framework. Naked Objects is a powerful tool that can give you a significant advantage in the development of business systems. It gives you the ability to prototype a software application so quickly that it can be performed during information gathering phases of a project. It gives you the power to codevelop the core business model of your application with a non-developer business expert at your side. No prerequisite knowledge of Naked Objects is required.

Session Goals: To learn to write software applications (possibly system prototypes) using the NakedObjects framework. Developing applications that use NakedObjects requires knowledge of the conventions and contract of this framework. NakedObjects is a fairly radical development in the domain of business software application development. Awareness of the concepts and implications of expressive systems is an important secondary goal. Prerequisites: Basic understanding of the Java programming language and of object-oriented programming and design. Familiarity in the domain of business application software development. Session Rating: Intermediate Category: Architecture

By Eitan Suez

JiBX is an open source XML data binding API for Java. JiBX is younger than most other APIs in this space (Castor XML, BEA XMLBeans, JAXB). JiBX's philosophy on data binding is that: [a] databinding should be fast, and [b] databinding frameworks should allow for the divergence and evolution of your codebase from its xml representation. JiBX excels on both counts and consequently is a practical tool for the purpose of data binding. In this session, Eitan will be covering all aspects of Dennis Sosnoski's JiBX framework.

Session Goals: To learn the JiBX API in detail. JiBX can considerably simplify the task of parsing XML content into business objects and generating XML representations of these business objects. Prerequisites: Basic understanding of XML, but not of any of the variety of standards that build upon that foundation. Basic understanding of the Java programming language. Session Rating: Intermediate Category: XML/Web Services

By Bruce Tate

This session, for the Spring beginner, helps you: • Understand dependency injection and inversion of control • Know the meaning of lightweight containers and Spring • Understand the basic pieces of Spring • See core Spring modules in action, including Persistence, AOP, transactions.

Attendees need not know anything about Spring. This session does talk about integration with core J2EE frameworks like JDBC and transactions.

The Spring framework is one of the fastest growing open source frameworks. New job postings are gaining rapidly, and many customers are adopting Spring instead of heavier alternatives. In this session, we’ll introduce Spring. You’ll see how Spring can give you much of the power of EJB, without the complexity or pain. Spring uses concepts like dependency injection and aspect oriented programming to ease standard enterprise development. Spring developers write plain, ordinary Java objects (POJOs), instead of sophisticated components. In this session, you’ll see a basic Spring application. You’ll also see some details about some of the enterprise integration strategies, including: • Spring

By Bruce Tate

Agile programming is a collection of core principles and techniques that allow software developers to create lighter, more responsive applications, and to have fun doing it. Many established organizations are either openly or sub-conciously hostile to many of the principles of Agile development.

We'll explore the intersection of these new practices and old-world sensibilities, relying on real-world case studies to illustrate some of the compromises that are necessary to bridge the gap. In addition to technical and process aspects, we'll also spend some time talking about the business aspects, such as how Agile development affects contracts.

By Bruce Tate

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

This free-form session is intended to help attendees choose or validate a persistence framework. In it, the instructor will take questions from the audience, and tailor the session to the questions asked. Bruce will focus on three persistence frameworks: EJB, JDO and Hibernate. He’ll talk about the evolution of each of the frameworks. He’ll talk about the fundamental design philosophies of each, and what makes each unique and strong. But understanding technical strengths is not enough in the area of persistence. To make the best possible choice, a developer or architect must also understand the politics of persistence, and the marketing pressures that lead to the success or failure of each

By Bruce Tate

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

The Java programming language has been tremendously successful. Many of the roots of its success may be surprising to the audience. But every major programming language has a limited life cycle. While it’s true that Java and .NET seem to be the only games in town, some alternatives are beginning to emerge. In this session, we’ll discuss some of the limitations of the Java language, and the impact that they might have on the productivity of Java developers. We’ll then look at some of the innovations around other frameworks and languages, and some of the features of those languages that boost the productivity of other non-Java developers: • Typing, and why it matters • Code blocks and closur

By Dave Thomas

Ruby recently enjoyed its tenth birthday. Instead of cake and candles, the community celebrated by releasing a wave of new libraries and frameworks that make Ruby programming even easier. This talk features some of the best of these, as we explore Ruby.

We'll spend about half the session getting to know Ruby: the syntax, type system, blocks, iterators, and so on. Then we'll dive in and develop some real-world code using web services, RSS, and databases. If you want to come to the Rails talk, and you're not that familiar with Ruby, this talk is a good starting point.

By Dave Thomas

The Ruby on Rails framework has exploded onto the scene over the last few months. Propelled by some genuine benefits, and fueled by a whole lot of controversy, Rails seems here to stay. So, is it a Java killer? (No.) Is it a great way to develop certain classes of web application? (Yes.) Does it really deliver the 10-fold increase in developer productivity that some have claimed? (It depends...)

If you can't help thinking that there must be an easier way of developing web projects, come and join us as we construct an MVC-based Ruby on Rails application using the very latest libraries and tools. You'll get a taste of Ruby, and also a feel for some of the power and productivity gains offered by this remarkable framework. You'll need a grounding in Ruby to get the most from this talk; if you're not already a Ruby developer you might want to attend the Facets of Ruby talk before coming to this one.

By Dave Thomas

Are you frustrated by experts who can't tell you what to do, or by junior team members who refuse to see the big picture? How can you best develop careers: both yours and those of your teammates and managers? How can we learn to apply experience more effectively, and why do the many approaches designed to tame complexity actually end up increasing it?

Dave Thomas, of The Pragmatic Programmers, describes the solutions to these and other problems as he turns the Pragmatic Spotlight (and a good dose of twisted humor) on formal learning models, the Nursing profession, and streamlining sheep.

By Glenn Vanderburg

The Java Collections framework is a cornerstone of Java development. It's been a part of J2SE for six years now. Every Java developer knows it—how to create Lists, Maps, and Sets, how to put things into them and take things out, and how to iterate over the contents. But there's a lot more to the collections framework than that -- and very few programmers really know how to exploit the power that's just under the surface.

The basics of the collections classes are so simple that many developers haven't even thought to look for the additional power that's there. And it's not just built-in capabilities, either. The design of the collections framework makes possible several powerful techniques and patterns that can magnify your productivity, as well as helping you build systems that are efficient and scalable. It may seem strange to give a talk on a framework that every Java programmer already knows. But in every project I've worked on for the past six years, I've seen a lot of code that uses the collections poorly. More often than not, that code was written by skilled programmers with significant Java experienc

By Glenn Vanderburg

Most of the time, Java's automatic memory management works really well—it's one of the things that makes programming in Java a pleasant and productive experience, and it's nice that we don't have to worry about managing memory manually. However, although it's usually nice to ignore memory management, occasionally we have to pay close attention. Sometimes we need to take control of certain aspects of memory management. Sometimes Java programs do exhibit memory leaks, or unacceptably long garbage collection pauses, or very poor overall performance. But because Java's memory management is supposed to be "fully automatic," it can be difficult to find out what's really going on inside the VM.

Java memory management is just like most labor-saving simplifications: it works well most of the time, but for the weird edge cases when it doesn't work quite right, it can be a nightmare. This talk opens the hood, examining the inner workings of Java's memory system, including allocation and garbage collection. We'll look at how to control the memory system and interact with it, what's costly and what's not, how to tune the garbage collector and when to switch to a different GC algorithm, and other topics.

By Glenn Vanderburg

With the sudden importance of Ajax, it's time to take JavaScript seriously. That means learning it the right way: looking at the fundamentals of the language and surveying its strengths and weaknesses, instead of just copying other people's poorly written examples.

JavaScript got a bum rap. It's almost universally derided among serious programmers for being a toy language, or for its strange characteristics, or bugs, or slowness, or because it's only good for adding useless window dressing to web pages. But JavaScript is actually a very nice little language which is popping up everywhere these days (not just in Ajax apps). Sure, JavaScript is quirky, but its problems are mostly due to history, association, and misunderstanding. Especially misunderstanding. Let's face it: most developers learned JavaScript by looking at examples in web pages they found online, and few of those examples are paragons of JavaScript style. Other developers learned JavaScr

By Glenn Vanderburg

We've been writing web applications now for 10 years, and they're still no fun. They're awkward and clumsy to write. Internally, they're overly complicated (which almost invariably means that they're buggy). Meanwhile, they're usually too primitive externally. To put it another way: the web programming model is so cumbersome for programmers that the users pay—through reduced features, clumsy interaction, bugs, and poor performance. There's a better way. I know -- who needs another web framework? But Seaside makes even Rails look primitive.

Seaside represents a new generation of web frameworks. Using it, web development is simple. A little code goes a long way. The code is simple and clear. There are powerful development tools that magnify your productivity. You can focus on making your web application good rather than having to strive with all your might just to make it work. It might not be perfect for your situation—it's written in Smalltalk, for one thing, which presents a barrier to adoption in many organizations. And it's not quite as scalable as more traditional web frameworks. But for most applications, it would drastically reduce the development effort while also increasing the usefulness and robustness of the applicat

By Craig Walls

Mistakes happen. Bad ideas happen. Have you ever felt that sinking feeling when you accidentally erase an entire directory of source code? Or have you ever realized that the oh-so-clever refactoring you applied yesterday is causing performance issues today? Wouldn't it be great if you could turn back time?

Version control is a critical component of software development. It is the magic time machine that lets you go back to a better time when directories weren't deleted and bad ideas didn't wreak havoc on your servers. Subversion is a relatively new version control system that is meant to be a replacement for CVS. In this session, we'll walk though several common day-to-day (and a few of the more eccentric) Subversion tasks. You'll see how your project can benefit from storing your code in Subversion. As a bonus, we'll also explore tools that can be added to Subversion to make it an even greater pleasure to work with.

By Craig Walls

Where Spring promotes loose-coupling between your application objects, service-oriented architecture (SOA) encourages loose-coupling between applications that interact with each other.

In this presentation, I'll show you how to build loosely-coupled architectures based on Spring-enabled services. You'll see how to use Axis and XFire to turn your Java objects into web-services and also see how to configure services within the Mule enterprise service bus.

By Craig Walls

Windows changed everything. Back in the days of MS-DOS, you could only run one application at a time. Switching between writing a letter and balancing your checkbook involved closing a word processor and opening a spreadsheet. But now you can be running dozens of applications simultaneously, each inside its own window. And now switching from one application to another may be as simple as a shift of your eye or a click of the mouse button.

Portals do for web applications what Windows did for MS-DOS. With traditional web applications such activities as checking the weather, viewing baseball scores, and keeping up with the latest news involves visiting several distinct web applications. But with portals, all of these applications, presented as portlets, can be combined into a single web-page for convenient and concise viewing. In this session, I'll demonstrate how to build portlet application using Spring Portlet MVC, an adaptation of the Spring MVC framework that is geared toward writing JSR-168 compliant portlet applications.