By Neal Ford

Is Service Oriented Architecture the next wave of distributed computing or just the same old crap in a shiny new package? This session provides an overview of what most people agree is the definition of SOA. I talk about SOA, ESB, CORBA, your MOM, and a bunch of other acronyms.

This session is a pragmatic look at SOA from a developer perspective, including such (never talked about) topics like tranports, granularity, versioning services, transformations, and whether you should be doing this or not. I show lots of slides with diagrams and talk about how to evolve towards an SOA. SOA can work if you ignore the hype and focus on the real meat: building loosely coupled message-based applications. This session discusses just that.

By Neal Ford

This session talks about how to actually get XP done in the real world (and what to tell your boss).

Extreme programming sounds a little too ?ESPN2? for most managers, but there is a lot of sound engineering behind its principles. My employer, ThoughtWorks, has been extremely successful using the full XP stack and we have developed lots of experience with it. This session talks about how to do XP in the real world. XP is all about feedback loops, so I discuss how to replace the radical sounding ones with more palatable ones. I talk about the parts of XP that are absolutely vital (unit testing, collective ownership, continuous integration, etc) and the ones that you can introduce a little more slowly (pair programming, only a 40 hour work week). This session focuses on the practicality of XP and how you can adopt it at your organization. I also talk about political battles with managers, other departments, and barriers that pop up anytime you try to introduce change in a large enterprise. Discussion is encouraged (required) in this session.

Key Session Points: XP and Feedback Loops A pragmatic look at the XP practices     The planning game     Small releases     Metaphor     Simple design     Testing     Refactoring     Pair programming     Collective ownership     Continuous integration     40-hour week     On-site customer     Coding standards XP in the real world

By Neal Ford

This session shows you how to become a more productive programmer every day by using tools that you didn't know you already had.

<grizzled-programmer>
Why, in my day, we didn't have any fancy Gooey tools -- we did everything from the command line and we liked it. And, we got a lot more done than all you point-and-click monkeys
<grizzled-programmer>
Have you ever noticed that some old-school developers can run rings around you at the keyboard? Have you ever seen a 2 week problem become a 2 hour solution because someone knew a better way to solve it? This session is about all the command line and other tools that are extremely powerful yet widely neglected in today's graphical environments. This session shows you how to take advantage of those tools whether you run Windows, *Nix, or Mac. It focuses on specific recipes to make your job easier. I'll show you how to get around your computer in a hurry (no more clicking around in trees), how to find anything fast, how to manage projects and artifacts from the command line, how to automate the repetative tasks you find yourself doing every single day, how to stop repeating yourself, and how to stop repeating yourself. This session is guaranteed to improve your developer productivity by an order of magnitude.

Key Session Points

• Creating a common environment
• The Unix philosophy (without Granola or sandals)
• Automating common programming tasks
• Getting around in a hurry
• Searching techniques
• Text techniques
• Project management from the command line
• Stop repeating yourself
• Tying it together

By Neal Ford

Lots of developers want to use Agile development technique but don't know where to start. This session discusses how to get started with Agility, the key benefits you can expect, and the pitfalls to avoid.

There's the perfect world, and then there's the world you have to live in. Lots of organizations would like to reap the benefits of Agile development techniques but don't know how to get started. This session discusses the key benefits you can derive from Agile software development so that you can decide for yourself how many agile techniques will work within your organization. I discuss project planning and estimation, how to benefit from pair programming when you aren't allowed to pair, how to measure your progress, and other project milestones. Agile software development isn't just an unrelated set of activities, it is a discipline. Once you understand the component parts of the discipline, you can apply them to your less-than-perfect world.

Key Session Points

• What makes Agile tick?
• Flavors of agility
• Selectively applying agile practices
• Enforcing code quality
• Measuring progress
• Iterating over the waterfall
• Lessons learned

By Ted Neward

Ever wished you could just put parts of your program in end-users' hands and let them build the infinite little changes they want? Ever thought about how you might make your application more robust by writing less code, not more? Embed a scripting engine into your application--complete with the safeguards necessary to ensure that users can't do anything they shouldn't be able to--and release yourself from the Principle of Perpetual Enslavement.

This presentation will describe how to embed a scripting engine using BSF and/or Java6, discuss the pros and cons of the various ones available, and how to put enough safeguards around the scripts to make sure that your application can't be hijacked by bad users' scripts. (For any intermediate Java audience, as a 90-minute presentation. Ask about the possibility of delivering it as a half-day or full-day tutorial.)

By Ted Neward

Managing state--both transient state (like your shopping cart) and your durable state (like your order placements, your inventory management forms, and so on)--is tricky in an enteprrise application. In this talk, we'll examine some of the trickiness, both high-level and low-.

We'll talk about the various forms of data persistence, including "procedural-first", "relational-first" and "object-first" approaches. We'll also talk about the costs of data-access logic, and ways to mitigate those costs. In short, if you store or use data in an enterprise Java application (be it J2EE or Spring or otherwise), you'll want to be here.

By Ted Neward

Java5 introduced a whole slew of new features, including annotations (JSR 175), new language features (the enhanced for loop, generics, static imports, and more), new library support (java.lang.instrument, among others), and some interesting enhancements to the virtual machine itself.

This presentation will go over those features, explain why they matter, and how you can take advantage of them in a variety of different practical ways. (For an audience comfortable with Java 1.4, as a 90-minute or half-day presentation.)

By Ted Neward

There's a lot of talk about web services, and most of it falls into one of two categories: lots of low-level talk about vendor-specific tools and extensions, or lots of high-level talk that never shows you a line of code. XML services aren't that hard, and in this talk, we'll see how, why and when to do one.

We'll talk about XML (and why it's the format used), Schema (and the core subset of Schema to focus on using, along with tools to help work with Schema more easily), SOAP (and why it's really crucial to making XML services work), and more.

By Brian Sletten

Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.

NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.

Come see how this open source / commercial product can change the way you think about building software.

NetKernel makes the things you are doing now easier, but also makes new types of systems possible.

A wise man once said, "XML is like lye. It is very useful, but humans shouldn't touch it." If you've had to incorporate XML into your project by hand, you have probably been burned by getting too close. NetKernel turns this wisdom on its head and encourages you to use XML like the liquid data stream you want it to be.

But, XML is only part of the story. Resource-oriented computing is a generalized and revolutionary approach to modern, flexible systems. There is less code to write, but it is more fun to do. Orchestration of existing services and data sources is faster, easier and more encompassing than with more conventional technologies.

This talk will help explain what NetKernel is (app server? pipeline tool? embedded SOA?) and, through a comprehensive set of examples, give you a glimpse at a deeper software reality than you might have thought possible.

Disclaimer: There will be no blue pills given to you to make you forget what you have seen. Come with an open mind.

By Brian Sletten

Most people new to Aspect-Oriented Programming (AOP) are fed up with separation of concerns zealots explaining how great their techniques are at dealing with... logging. Ok, you get it. Logging is a cross-cutting concern that can be appropriately modularized. What else does AOP have to offer? A lot, it turns out. This talk will give an introduction to the motivations of AOP as well as a series of concrete examples drawn from enterprise and client side Java. Come learn how AspectJ-flavored AOP can begin to benefit you immediately either in development or production environments. Learn how to enforce architectural policies, find Swing threading issues, reduce the invasiveness of the Observer design pattern or even improve the reusability of your domain models. Now that Spring 2.0 provides support for AspectJ, the time has never been better to learn about these new (but backwards compatible) ways of thinking about building software.

Attendees will learn about
The history and reasons behind AOP
Development-oriented aspects that can be useful, but compiled out of production code
Production-oriented aspects that can simplify development and ease the burden of future changes
Basic AspectJ usage and jargon How to use AspectJ with Spring

Rating: Intermediate
Category: Architecture/Languages, Client Side Java, Server Side Java Prerequisites: Basic Java. Some level of AOP understanding is helpful, but not required. The pace of the introduction will depend on the average level of exposure the audience has previously had to AOP.

By Brian Sletten

Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al inform us that what we have seen so far is just the beginning. His original plans at CERN were larger and grander. The Semantic Web is the new vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. While there are many naysayers chiding such grand visions, there are also pragmatic and useful technologies emerging that can be applied today.

Attendees will learn:

The history and motivations behind the Semantic Web The technology stack that will make it happen (including RDF and OWL) An overview of tools and technologies that are beginning to satisfy the vision

This talk stands on its own, but feeds into the "Experiencing the Semantic Web" talk which is more hands on.

Rating: Intermediate
Prerequisites: This is all so new, most engineers will find something to excite them.

By Venkat Subramaniam

Rule based programming allows us to develop applications using declarative rules. These can simplify development in applications where such rules based knowledge is used for decision making.

In this presentation we will take a look at the tools and techniques for developing rule based applications. We will take a look at open source tools, discuss their strengths, capabilities, and limitations.

By Venkat Subramaniam

Refactoring is one of the core practices in Agile Software Development. Refactoring is based on some core principles that apply to more than writing good code. But, what's refactoring? Why should you do it? How do you go about doing that? What tools are available to successfully refactor your App?

In this presentation we will address each of these questions. We will take an examples based approach to look at code that can benefit from refactoring. We will discuss how to identify a case for refactoring. Then we will use tools to help us refactor.

By Venkat Subramaniam

Portals and Portlets allow you to personalize your web application. However, developing and deploying portlets across different portals can be a challenge. What is WSRP and JSR-168. How are these related and how are these different? Are these competing technologies or do they work with each other?

In this presentation we will introduce you to these standards and related technologies. We will take an example based approach. We will take closer look at tools and techniques for portlet development.

By Venkat Subramaniam

You have worked on software projects with varying degree of success. What were the reasons for the success of your last project? What were the reasons for those that failed? A number of issues contribute to project success - some non-technical in nature. In this presentation the speaker will share with you practices in a number of areas including coding, developer attitude, debugging, and feedback. The discussions are based on the book with the same title as the talk.

In this session you will learn about practices beyond what well know methodologies prescribe. While we reemphasize some popular practices, we will also discuss other often overlooked, but important practices - practices that contribute to success of projects.

By Venkat Subramaniam

As a Java developer, you have taken the time to learn the basics of the language and relevant parts of its rich API. However, you need more than that to develop serious industrial strength applications. In this presentation, the speaker will introduce you to a number of open source tools which you can use to improve your application quality and your development process.

Instead of simply going through a laundry list of tools available, the speaker will engage you with motivation to use these tools, and show examples of their practical use.

We will start by looking at tools for unit testing and creating mock objects. We will then take a look at tools that will help you to ensure certain performance of your critical code.

You know writing good code is more than simply using an OO language. We will look at tools that will help you with code metrics, so you can analyze, and refactor your code to reduce coupling and undesirable dependencies.

But, what about hidden critical errors in your code, like synchronization problems that may potentially lead to deadlocks? We will look at how you can use open source tools to proactively eliminate these from your code.

Finally, we will look at tools available for automating your project and getting extreme feedback though out the development cycle.

By Mike Cohn

The technique of expressing requirements as user stories is one of the most broadly applicable techniques introduced by Extreme Programming. User stories are an effective approach on all time constrained projects, not just those using XP.

In this class we will look at how to identify and write good user stories. The class will describe the six attributes all good stories must exhibit and present thirteen guidelines for writing better stories. We will explore how user role modeling can help when gathering a project’s initial stories. This class will be equally suited for programmers, testers, managers and even customers and analysts who are interested in applying these agile techniques to their projects.

By Mike Cohn

Estimating and planning are key skills. A good plan helps both the organization and the developers working on the project. In this session you’ll learn how an easy and effective approach to estimating and planning that can help you create more realistic plans.

Planning is important for all projects, even for projects using agile processes such as XP, Scrum, or Feature-Driven Development. Unfortunately, we’ve all seen so many worthless plans that we’d like to throw them away altogether. The good news is that it is possible to create a project plan that looks forward six to nine months that can be accurate and useful. In this class we will look at why traditional plans fail but why planning is still necessary even on agile projects. We will look at various approaches to estimating including unit-less points and ideal time. The class will describe four techniques for deriving estimates as well as when and how to re-estimate. We will look at techniques to create a plan that dramatically improves the project’s chances of on-time completion. Also discussed will be using velocity to track progress against the plan. This class will be equally suited for managers, programmers, testers, or anyone involved in estimating or planning a project.

By Mike Cohn

There is a myth that agile projects do not need project management and that they cannot be estimated and planned. In this session we will dispel those rumors and learn why the job of the agile project manager is to do more than just buy pizza and get out of the way.

In this session you will learn why a self-organizing team will always outperform a team managed through command-and-control, how to tell when a project is on track, and how and when to make an adaptive action to get it back on track. This session will describe the four types of agile teams and the appropriate project management style for each type. You will learn how to move a team quickly from the Telling phase, through the Selling phase, and into true agility. You will also learn how to achieve unified commitment on your team through powerful focusing tools such as the product vision box, the one-page product data sheet, and elevator statement.

By Mike Cohn

Almost all of us have worked on too many projects that have failed because of economic reasons rather than technical reasons. Just as the technical team is required to estimate the effort that will go into a project, a marketing or product management team should estimate the benefits of doing the project. Benefits can come in the form of additional sales, increased customer retention, increased operating efficiencies, and so on.

In this session we will look at return on investment (ROI) as well as traditional discounted cash flow methods such as net present value (NPV), and discounted payback period. We will also look at newer approaches such as economic value added (EVA).

The math is easy, the concepts are powerful. You will return home with practical knowledge about how to apply these straight-forward techniques to prioritizing and selecting projects.

By Mike Cohn

Projects struggle for many reasons—overly aggressive deadlines, unproven technologies, scope creep, team dynamics, communication problems, and inter-team coordination are just some of the reasons. If not given attention, these problems can ultimately cause a project to fail entirely. However, if you act early and in the right way, most struggling projects can be turned around.

In this class we will look at how to determine what is causing a project to fail and then at what to do about it. You will learn how which remedies to consider in which situations and how to determine the appropriateness of each. Also covered will be advice on communicating the project correction plan to executives or project sponsors who may still think the project is on track. The class offers practical advice from the presenter’s years of experience in assessing both successful and unsuccessful projects.

By Scott Davis

How do you get started with an Agile development methodology? Everyone has been talking about eXtreme Programming for years, but how do you get it introduced to your team? Many times, you're not simply transitioning from from one methodology to another -- you're introducing a methodology for the first time. Adding structure to a previously unstructured endeavor. Adding a touch of discipline where programmers once roamed free.

This presentation talks about how to introduce Agile practices slowly. Think of it as refactoring your team iteratively. If you drop 25 new "best practices" on developers all at once, the chances of getting any of them to stick is slim. If you start with one practice and get buy-in on it, sneaking in the next one (especially if it is complementary) is far easier.

• starting with source control
• easing into iterations with XPlanner
• is your team ready for pair programming?
• writing your first unit tests
• evaluating your code base for unit test coverage

By Scott Davis

In this talk, we'll survey the web services exposed by leading websites (Google, Yahoo, Amazon, eBay) and discuss how they are driving the AJAX revolution. You'll see examples of RESTful, SOAP, and JSON web services, as well as the strengths and weaknesses of each.

Everyone seems to be talking about AJAX and Web 2.0 these days. While the UIs of AJAX-enabled websites such as Google Maps and Flickr are undeniably cool, they wouldn't exist without a strong SOA/Web Services infrastructure behind the scenes.

"Web Services" is an overloaded term. While SOAP is a mainstay in the web services world, there are other equally valid flavors (REST, JSON) that accomplish the same goal -- decoupling the data from the presentation layer, the platform, and even the programming language used.

Rather than talking about web services in the abstract, this talk shows examples of each flavor of web services as it is used in the wild by leading web companies. They have all taken slightly different approaches to the same problem. We'll compare and contrast their public-facing offerings.

There is no one "right way" to expose your API via web services. After this talk, you should have a better idea of the relative strengths and weaknesses of each variant.

By Scott Davis

Mark Twain once said, "Everyone talks about the weather, but nobody does anything about it." Do you feel the same way about Unit Testing? Are you actively testing your code, or are you just thinking about testing your code... some day... once you get some more free time...

Unit testing offers benefits beyond the obvious. A happy side effect of writing unit tests is that your code ends up being better architected. By forcing you to be a consumer of your own code outside of the context of the main application, you end up seeing your code in a different light. Hidden dependencies get flushed out early. Good unit tests force your code to be more loosely coupled and highly cohesive.

This presentation is a survey of the testing ecosystem. A good testing infrastructure should include more than just JUnit. Cobertura, a test coverage tool, shows you how much of your code base is being tested. Writing test cases in Groovy adds a measure of flexibility that makes working with XML (and string data in general) a piece of cake. EasyMock allows you to test interfaces instead of implementations (and also avoid having to hand-code and maintain your own mock objects). We'll also look at functional testing libraries like HttpUnit, DbUnit, and JUnitPerf that allow you to test how your code behaves out in the wild, interacting with real subsystems instead of just mocks.

Most importantly, you'll see these tools live in action -- real code examples instead a simple slideware overview. Rather than looking at each tool in isolation, you'll see how they interact and complement each other. Rather than just talking about testing, we'll (finally) do something about it.

By Ben Galbraith

Ajax -- called DHTML just a few months ago -- has revolutionized (or "radically iterated", if you like) web application development in the short few months since the term was coined.

What is it all about? Why are we excited about a set of capabilites that have been sitting in our browser for years? What can you do with it? And, how can you do it?

Ajax, short for Asynchronous JavaScript and XML, is a technique for communicating with servers from within a web page without causing a page refresh.

This session provides an introduction to Ajax and an orientation to the state of the ajaxian universe. The basic ajaxian techniques will be demonstrated through live coding, and more advanced examples of Ajax will be demonstrated and deconstructed.

Attendees will understand how the Google Maps UI is built (and why it isn't as hard as it looks), how Ajax can improve portals, community sites, and pretty much any other type of web application.

Furthermore, the issues surrounding how to create an Ajax application that doesn't turn into an unmaintainable pile of hacked up crap JavaScript will be discussed.

At the end of the session, an off-line capable, web services consuming Ajax RSS aggregator will also be demonstrated.

This talk will be presented by one or more of the founders of Ajaxian.com.

The session "Ajaxian JavaScript Frameworks" complements this session, and dives deeper into specifics on how to use many of the frameworks introduced in this session.

By Ben Galbraith

In the "Introduction to Ajax" session, we discuss what Ajax is, how it works, and how others are using it.

This session goes deeper into Ajax by reviewing the existing JavaScript frameworks that aim to make it easier.

The scope of the frameworks is all over the made, from unit testing JavaScript to deconstructing other websites to making it easier to create your own ajaxian effects.

If you want to easily add some Ajax to your site, come to this talk, presented by one or more of the founders of Ajaxian.com.

By Ben Galbraith

Java's Swing GUI toolkit is one of the most powerful and flexible frameworks available for creating professional, high-quality desktop applications. Along with its considerable abilities, however, comes considerable complexity. Swing does not have a reputation for ease of use (despite being much easier than many of its competitors--but that's another story). If you could combine the Swings power with the productivity of easier, more restrictive tools, such as Microsoft's Visual Basic - you'd have an incredible tool for application development.

This presentation talks about eight techniques you can employ to realize such an environment, such as how you can successfully integrate GUI builders and XUL frameworks into your project, making it much easier to set and retrieve values on Swing components, how to make it trivial to make JTables easy to use, and more.

Along with the presentation and slides, attendees will be able to download open source code they can use in their projects today to implement these ideas.

By David Geary

In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).

JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.

Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.

This session is taught by a member of the JSF Expert Group for JSF 1.0 and 2.0., and co-author of the best-selling book on JSF: Core JavaServer Faces. David will take you through a whirlwind introduction to JSF including what JSF is, how it was developed, and how you can best take advantage of the technology. Here is a list of topics:

Components, managed beans, value expressions, and static navigation i18n, CSS, and actions The Faces Context and Faces messages The JSF Event Model Using JavaScript with JSF

This introduction to JSF also contains 5 live-code demos, where David will develop a simple, but robust application during the course of the session.

Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.

By David Geary

In 2005, JSF hit its stride, as evidenced from overwhelming support from both vendors and the open-source community. JSF 1.0 had plenty of holes, but open-source projects have arisen to address those needs. This session takes a look at three of those projects: Tomahawk (MyFaces component library) FaceletsSeam

MyFaces is an open-source implementation of the JSF spec. In addition, MyFaces developers got a little carried away and also developed a useful set of custom components that you can use in your own applications, regardless of whether you use MyFaces as your JSF implementation. Those components are now packaged separately from MyFaces under the name Tomahawk.

Facelets is an open-source project from java.net that lets you implement views with Tapestry-like HTML pages. That technique is a powerful feature that lets graphic designers and software developers work separately in parallel.

Seam is a framework from JBoss that provides a component model that unifies the EJB and JSF component models. Seam makes great use of annotations to meld EJBs and JSF components in a seamless fashion (thus the name).

Lots is happening in the JSF space. Come to this talk and learn about these three exciting open-source projects.

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

JavaServer Faces is a perfect platform for implementing Web 2.0 interfaces with Ajax. This session explores how you can use these two potent technologies--JSF and Ajax--together to create applications that look and behave like desktop applications but run in the browser.

JavaServer Faces, with a mature component model and flexible lifecyle, is a perfect platform for implementing Web 2.0 user interfaces with Ajax. This session explores using JSF and Ajax to create applications that act like desktop applications but run in a browser.

We'll start with a quick look at implementing basic Ajax in a JSF application. Then, once your bloodthirst has been slaked, we'll dive deeper into Ajaxian Faces dynamics with a form completion demo that requires its implementor to understand two simple, but vital facts about JSF.

If you're savvy, you probably use client-side validation to augment your server side validation logic, which parenthetically, is no no-brainer in either of the leading web application frameworks, JSF or Rails. But anyway, client-side validation is old school. All the cool developers nowadays use Ajax to implement realtime validation, where you sneak a trip to the server as an unwary user types into your input fields. But to accomplish that, we'll have to dive even deeper into JSF, with concerns such as accessing view state and accounting for client-side state saving.

All of this Ajax development is great fun, but most of it is best relegated to components and frameworks, which are the topics that will wrap up our session. We'll see how to keep your JavaScript separate from your JSF components and how to pass JSP tag attributes all the way through to JavaScript. Finally, we'll take a look at Ajax4jsf, a JSF component library with a tag library that blends Ajax into JSF in a natural, intuitive way without having to write JavaScript.

As web developers, we've been handcuffed long enough by the shackles of Web 1.0 development. Come to this session and see the brave new world of Web 2.0 development with one of the hottest web application frameworks.

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

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 AOP • Transactions • Persistence • Model/view/controller

When the session is over, you won’t be an expert, but you should have a much clearer understanding of what Spring does, what it doesn’t do, and why it’s growing so rapidly.

By Stuart Halloway

Dependency Injection (DI) is the cornerstone of Spring. The core concept is quite simple, but (surprise!) actual practice can become complex. To take full advantage of Spring DI, you need to understand not only the basics on configuration, but also the container lifecycle model and the various hooks provided by the framework.

Topics will include

• The difference between DI and Continuous Integration
• Setter Injection
• Constructor Injection
• Factory Injection
• Bean lifecycle
• Method Injection
• Using the ApplicationContext
• Custom PropertyEditors

By Stuart Halloway

Ajax applications have unique architectural challenges and opportunities. This presentation will show you how to take advantage of the Ajax's strengths, and work around its quirks.

We'll start with an overview of Ajax, and then dive right into an extended example where we add Ajax to an existing web application. Along the way we'll cover several tools that we use to aid in Ajax development: The JavaScript Shell, Firebug, and the Web Developer's Toolbar. We'll also look at two popular JavaScript Ajax libraries: Prototype and Scriptaculous.

With the example application under our belts, we'll move to a discussion of Ajax architectural questions, including:

• How do I select an Ajax library?
• What format data should my Ajax calls use: XML, JSON, HTML, or other?
• How do I handle the back button and deep linking in Ajax?

Prior exposure to Ajax and JavaScript is useful but not required.

By Stuart Halloway

Learn to use Spring AOP, aspect injection. and AspectJ integration

Spring provides powerful support for Aspect-Oriented Programming (AOP), via

• Spring Advisors
• Dependency Injection for Aspects
• Integration with AspectJ

In this session you will learn to use Spring AOP in real-world settings. We'll start with the basics of programmatic pointcuts, advice, and joint points. Then, we'll integrate these into the application Spring-style, using Dependency Injection.

With the basics out of the way, we'll move to meatier questions, including:

• How (and when) should I step up to AspectJ?
• How are Aspects implemented, and what are the performance implications?
• What are the alternatives to Aspects?

Attendees will get more out of this presentation if they have a basic knowledge of Spring and Dependency Injection.

By Stuart Halloway

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 1.4. Both of these are appropriate for production use.

Finally, we'll look at common mistakes in multi-threaded programming. The most common mistake is using threads when you don't need them. We'll look at alternatives to threads, and how to choose between them.

By Stuart Halloway

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 Howard Lewis Ship

An introduction to the Apache Tapestry web application framework, which will explain the concepts and features of the framework with some simple applications. We'll discsuss Tapestry forms, request cycle, component object model. The use of several important components, including BeanForm and Table will be highlighted, along with meta-programming using the Trails framework.

Tapestry is a powerful open-source Java web application framework that stands apart from most other technologies used for creating web applications ? it is based on highly reusable components, which are assembled to form complete pages. This session will get you started with Tapestry, showing how to build a simple form-based application. Along the way, we'll see how Tapestry simplifies your job: We'll see how Tapestry HTML templates are easier to create and maintain than JavaServer pages (JSPs). We'll see how Tapestry's built in error reporting lets you find and correct errors with startling speed. We'll see how Tapestry takes over responsibility for building and interpreting application URLs, eliminating large amounts of boring, error-prone, manual coding. Most importantly, we'll see how Tapestry bridges from the stateless world of HTTP and servlets into a more natural, more productive world of actual object oriented engineering ? allowing you to build applications in terms of objects with methods and properties (a true revolution if you are used to traditional servlets).

We'll also take a peek into more advanced aspects of Tapestry, such as its input validation subsystem that provides server- and client-side validation, as well as more advanced Tapestry components such as Table (a powerful data grid), and the Trails meta-framework that creates complete applications without almost no coding. Once you've learned a little bit about Tapestry, you might find it hard to go back to your old approach!

By Howard Lewis Ship

In Tapestry, components are not an add-on; in fact, anything but! Tapestry components are integral to the entire framework ? if something dynamic is going on in a page, there's a component involved.

When building Tapestry applications, a constant problem solving approach is to create new components. Tapestry makes creating components very, very easy. In this session, we'll see how to create simple output-only components, and how to create components with their own templates. We'll also see how to create components that can have interactions with the user independent of the containing page. Tapestry is designed so that the components just drop in and work, and we'll touch on some advanced services included in Tapestry, such as JavaScript generation.

By Howard Lewis Ship

You've heard about unit testing but were daunted when it came time to put the pedal to the metal. That's because JUnit is just one tool and there's others you need to learn about, including the wonderful and wierd EasyMock and the easy and powerful TestNG.

Unit testing with JUnit only gets you so far; even when you've refactored your code and hidden all your implementations behinds interfaces you are still stuck with the problem of testing the individual pieces. If you've hit this point and despaired, know that there are tools to help ... including the wierd and wonderful EasyMock. We'll discuss unit testing in general, and how EasyMock is used to to generate mock objects, allowing you test each class in isolation. We'll also leave JUnit behind and investigate using TestNG, a modern and improved test framework. We'll then learn how to tame EasyMock's awkward API with some modest refactoring and naming conventions.

By Tom Marrs

Have you tried to deploy J2EE Web Services and thrown up your hands in frustration at the lack of tool support? Do you want to know how to develop and deploy Java EE-compliant Web Services so that they work every time? Would you like to see how to develop/deploy Web Services in Spring with XFire? Are you wondering if SOA is just hype and fluff? Do you think SOA is just marketing's re-packaging of Web Services? Would you like to know how Web Services and SOA (Service-Oriented Architecture) fit together? If so, then this talk is for you.

The new Java EE 5 Web Services standard and Spring/XFire were both designed for interoperability and simplicity. We'll show how to develop a POJO (Plain Old Java Object) as a Web Service using each technology stack. We'll also show how to design Web Services and how this fits with SOA. This presentation covers:
* Web Services Overview * Business Reasons for Using Web Services * Java EE 5 and Web Services (including Java EE 5 annotations) * Implementing/Deploying a Java EE 5 Web Service * Implementing/Deploying a Spring/XFire Web Service * Developing a Web Service Client * Web Services Architecture and SOA

Intended audience: Experienced Java/EE architects & developers

By Tom Marrs

Have you wasted time writing lots of security-based code and ever wondered if there's a better way to add security to your application? Are you confused by declarative security? Have you read about JAAS (Java Authentication and Authorization Service) but wondered where it fits? Have you ever said, "Can I just see a working example"? If so, then this talk is for you.

If you're looking to restrict access to resources based on user roles, then J2EE declarative security is for you. You'll learn how to protect web pages and business logic without adding a single line of Java code to your business logic.
This presentation covers:

• J2EE Security Overview
• Web-based Security
• Protecting Access to Web-based Resources
• JAAS Overview
• Integrating JAAS with J2EE Security
• Configuring JAAS with JBoss and Tomcat
• Using Programmatic Security
• Integrating web-based security with business logic
  

We use Ant and XDoclet to deploy a simple J2EE-based web site using JSPs, Servlets, and EJBs. We will secure the application in an iterative style. We use JBoss as the reference implementation, but the core techniques shown here are applicable to any J2EE 1.4 application server.

Intended audience: Experienced Java/J2EE developers

By Chris Richardson

Key to making good design decisions is knowing the available options and understanding their respective benefits and drawbacks. This presentation looks at two important design decisions that you must make when developing the business logic for an enterprise Java application: how to organize the business logic and how to encapsulate the business logic.

The first part of the talk describes the two main ways to organize business logic: an object-oriented design (a.k.a domain model) and a procedural design (a.k.a. transaction script). You will learn how to implement the business logic using each of these approaches and which lightweight frameworks to use. We will cover the criteria that you can use to decide between the two approaches.

In the second part of the talk, you will learn about the different options for encapsulating the business logic: the traditional EJB façade pattern, the newer POJO façade pattern and the Open Session in View pattern (a.ka Exposed Domain Model pattern). We describe how to implement each of these patterns and their respective benefits and drawbacks.

By Chris Richardson

Object-oriented design (OOD) is good way to tackle the complexity of modern applications. Yet many complex, enterprise Java applications are written in a procedural style. One reason is because EJB2 created too many obstacles to using object-oriented design techniques. Fortunately, enterprise Java technologies have improved. Plain Object Java Objects (POJOs) and object/relational mapping frameworks such as Hibernate, JDO and EJB3 led to the revival of OOD.

In this presentation, you will learn how to implement business logic using a rich POJO domain model. We will compare and contrast a procedural design with an object-oriented design and describe the benefits of OOD. You will learn how non-invasive frameworks provide dependency injection and persistence for a domain model.

By Chris Richardson

The limitations of EJB2 led to the development of the extremely popular Spring and Hibernate frameworks. These frameworks replaced the cumbersome EJB2 programming model with a nimble, non-invasive Plain Old Java Object (POJO) –based model. But, now, the EJB3 specification has embraced many of the ideas made popular by Spring and Hibernate including POJOs, transparent persistence and dependency injection.

So what’s the future of Spring and Hibernate? Are they obsolete? In this presentation, you will learn the answers to these and other questions. We describe how EJB 3 persistence compares to Hibernate and how EJB3 services such as transaction management and dependency injection compare with those provide by Spring. You will learn the benefits and drawbacks of each of these frameworks.

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 Eitan Suez

An exercise in refactoring, playing with Java 5 annotations, varargs, JUnit, and more (see detail description for more).

This talk is a little story. It begins, innocently enough, with a speaker's dilemma: how to give an effective talk on Hibernate? The speaker quickly realizes that to he's going to have to automate some of the associated configuration and setup code. There's an interesting refactoring hurdle along the way, whereby the author:

[a] dreams he could be writing the code in JavaScript [b] tries out the Spring Framework's medicine for Hibernate [c] ends up simply using JUnit [d] gets inspired and writes his own mechanism to resolve the situation [e] finally, looks towards the future with a sigh, and thinks "AOP"

An exercise in refactoring, playing with Java 5 annotations, varargs, JUnit, and more.

By Eitan Suez

This talk covers the core of the Hibernate Object/Relational Mapping framework by example; that is: in a hands-on manner.

What does this mean? Two things: 1. Rather than spending 1.5 hours going from slide to slide, passively covering various aspects of the Hibernate framework, you'll be actively building a sample application, modeling, persisting, querying information using Hibernate 3.1 2. Hibernate today is a mature and rich framework consisting of many features. Discussion of features outside of the Hibernate "Core" will be sacrificed for the sake of presenting Hibernate in an active, "by example" style.

No a-priori knowledge of Hibernate is assumed. We'll cover the basics of Hibernate v3.1, XML mappings, the Hibernate Query Language (HQL), the Criteria API, custom UserType's, Components, and more! (This talk does not discuss auxiliary topics such as the EJB 3 persistence API, Annotations, or integrating Hibernate in managed (J2EE) environments).

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

The Ruby on Rails framework has unit and functional testing baked right in. In this talk we'll see how easy it is to get started with testing in Rails, and we'll explore jut how deep the testing support goes.

We'll look at the basics: unit testing models and functional testing views and controllers. But we'll dig deeper, looking at the supplied mock objects and seeing how easy it is to add our own. We'll also investigate test fixtures, using them to generate both static and dnamic test data. Finally, we'll have a quick look at performance testing.

By Dave Thomas

Ajax is becoming a requirement for new applications: it creates richer user experiences and more dynamic applications. However, doing Ajax by hand is difficult and error prone. The good news is that if you use Rails, you don't have to do Ajax the hard way.

Rails has built in helpers that support Ajax development, and comes packaged with the powerful prototype.js and script.aculo.us libraries.

Come see how Ajax can be made to work with your Rails applications as we built a very dynamic ToDo list, and see how Ajax can be made robust with a simple calculator.