By Neal Ford

When you were hired by your current employer, you may think it's because of your winning personality, your dazzling smile, or your encyclopedic knowledge of [insert technology here]. But it's not. You were hired for your ability to sit and concentrate for long periods of time to solve problems, then placed in an environment where it's utterly impossible to do that! Who decides that, despite overwhelming evidence that it's bad for productivity and people hate it, that you must sit in a cubicle? The furniture police! This keynote describes the frustrations of modern knowledge workers in their quest to actually get some work done, and solutions for how to gird yourself against all those distractions. I talk about environments, coding, acceleration, automation, and avoiding repetition as ways to defeat the mid-guided attempts to sap your ability to produce good work. And I give you ways to go on the lam from the furniture police and ammunition to fight back!

When you were hired by your current employer, you may think it's because of your winning personality, your dazzling smile, or your encyclopedic knowledge of [insert technology here]. But it's not. You were hired for your ability to sit and concentrate for long periods of time to solve problems, then placed in an environment where it's utterly impossible to do that! Who decides that, despite overwhelming evidence that it's bad for productivity and people hate it, that you must sit in a cubicle? The furniture police! This keynote describes the frustrations of modern knowledge workers in their quest to actually get some work done, and solutions for how to gird yourself against all those distrac

By Neal Ford

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain.

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with t

By Neal Ford

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

By Neal Ford

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

In The Productive Programmer, I identify 4 principles of productivity: acceleration, focus, automation, and canonicality. This session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. Canonicality (the DRY principle from The Pragm

By Neal Ford

BRING YOUR LAPTOP WITH YOU, BUT A LAPTOP ISN'T REQUIRED! Reading and hearing about agile practices is one thing, but actually doing it is completely different. This session puts you to work in an agile fashion, applying agile developer practices.

Reading and hearing about agile practices is one thing, but actually doing it is completely different. This session puts you to work in an agile fashion, applying agile developer practices. During this session, we're going to take a problem and iteratively develop the solution, using test-driven development, pair programming, retrospectives, pair rotation, and other agile development techniques. We should be able to get through about 3 20-minute iterations during the 90 minutes, giving you a hands-on feel for real agile development. If you have a laptop, bring it, but only half the class needs one, so if you don't have a laptop, don't let it discourage you. Come see what it's like to work on

By Neal Ford

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

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

By Neal Ford

This talk covers language techniques in Java, Groovy, and Ruby on how and why to create DSLs, and also covers the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

Domain specific languages have been the Next Big Thing for years now, but they have quietly started penetrating the development world. This talk covers language techniques in Java, Groovy, and Ruby on how and why to create DSLs. This session demonstrates with motivation for converting APIs into DSLs, and various patterns, anti-patterns, and best practices for how to achieve the optimum effect. This talk also covers the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

By Neal Ford

Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.

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

Key Session Points:

Regular expressions defined

Examples

Using t

By Neal Ford

Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.

This session shows one of the reasons that JRuby is the most

powerful mainstream language today: meta-programming. It shows tons of

meta-programming techniques in Ruby, including open classes, the shadow

meta-class, defining methods, method_ & const_missing, dynamically

adding and removing mixins, and more. And each of these comes with an

example that actually makes sense!

Session TopicsModulesStructsFreezingMessages and Dynamic InvocationThe Shadow Meta-classCode as ObjectsDelegationOpen ClassesAspectsMissing! Const Method ReflectionMixology

By Matthew McCullough

Open Source is not just a suite of libraries you consume within your application, but now reaches into the space of tools to help you troubleshoot and improve your applications.

This session will quickly survey a wide range of tools across the Java, Networking, Filesystem, SOAP, REST, HTML, CSS and JavaScript realms. We'll look at applications such as VisualVM, which help you analyze your heap and garbage collection cycles of both local and remote applications. Performance and load testing tools such as JMeter will expose bottlenecks, threading, and scalability concerns of everything from Java modules to Web Apps (even ones that don't use any Java).

Learn how web service tools such as SOAPui and TCPMon allow you to inspect your SOAP and REST calls at the data structure level, and how Firefox Poster lets you test web services right from the browser. And when only a raw look will do, we can always fall back on the venerable TCPDump.

This tool-centric presentation will expose developers to approaches to inspect, debug, tune and troubleshoot Java desktop apps, language-neutral web apps, and framework-neutral web services using Open Source Tools.

By Matthew McCullough

Watch Preview Video

Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.

In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition.

Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.

Prerequisite: Basic understanding of Subversion or similar version control system

By Matthew McCullough

Maven has been on the Java build tools scene for quite a number of years, but the adoption rate in enterprises is now going through the roof. Maven can seem daunting, but this presentation will equip existing Maven users with more efficient techniques and tools to overcome the biggest perceived Maven hurdles and build issues with ease.

We'll examine tools to help you find artifacts in central repositories, manage your corporation's internal Maven artifacts with a proxy tool such as Nexus, view and override dependency graphs, dependency management and multi-module best practices, create OS specific profiles, and leverage the latest Maven plugins for the top Java IDEs.

Topping it off, we will review migration paths from Ant, and why Maven just makes sense with your company's use of the ever growing web of open source libraries. This presentation will take beginning and mid-level Maven users up to a higher level of efficiency and mastery.

Prerequisite: Basic Maven knowledge

By Matthew McCullough

iPhone development is all the rage both in the mobile entertainment, social networking, and productivity application spaces. As a Java developer, prepare yourself to be a participant in aspects of this new breed and platform of development. Hop on board with a quick start to iPhone application coding in Objective-C and integration with some of our favorite Java web service back-ends such as RESTful Grails.

We'll build out a graphical demo application on the iPhone that depends on and responds to data from a Java web service; then we'll deploy it live to the desktop simulator, and finally, a real iPhone. This presentation will make you conversant in iPhone development procedures and able to make smart decisions about your back end Java web services ability to serve data to iPhone native client apps.

By Ted Neward

  Even though the Java 7 JSR has yet to be formed, some interesting things are beginning to emerge from Sun about what Java7 may include when its formal release contents are finally made public.

In this presentation, we'll examine some of the forthcoming details, including some of the JSR-166 "add-ons" like the Fork/Join framework, some of the proposals for extensions to the JVM to support dynamic languages, and the so-called "closures" proposals circulating around.

By Ted Neward

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

For an intermediate-level audience.

By Ted Neward

So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place.

In this presentation, we'll pick up where the "Platform Security" talk leaves off, and demonstrate how to engage the security model of the JVM at a much deeper level, regardless of your favorite programming language: Java, JRuby, Groovy, Scala, ....

Prerequisite: The Busy Java Developer's Guide to Platform Security

By Ted Neward

With the release of the OpenJDK source code, Java developers have been given a unique opportunity to peer inside the hood of the JVM, see what's there, and how Java code actually executes.

In this presentation, we'll talk about how to get the OpenJDK codebase, how to compile it (for both Windows and Linux systems), and point out some of the more interesting aspects of the JDK source base. Developers will walk away with a deeper appreciation for exactly what happens when they run Java code. Innocents beware--we're a long way from "Hello, Java" with this one.

By Ted Neward

For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes.

In this presentation, Java developers will see the basic breakdown of the Collection API designs, the relationship of the interfaces to the implementations, how to create a new Collection implementation, and how the new Collections introduced as part of JSR-166 (the concurrency JSR) and Java6 make their programming lives easier.

By Nathaniel Schutta

By now, developers know they aren't supposed to use tables for layout but despite good intentions, most look at CSS as a black art. While schooled in algorithms and data structures, when it comes to CSS, most of us just copy, paste and pray. This talk will remove some of the mystery surrounding styling web applications. We'll cover the basics and show you how libraries like YUI can make things even easier.

By now, developers know they aren't supposed to use tables for layout but despite good intentions, most look at CSS as a black art. While schooled in algorithms and data structures, when it comes to CSS, most of us just copy, paste and pray. This talk will remove some of the mystery surrounding styling web applications. We'll cover the basics and show you how libraries like YUI can make things even easier.

By Nathaniel Schutta

We've all used web applications that had us screaming at their creators - unfortunately sometimes we're the ones being cursed. Believe it or not, there are some simple steps we can take to ensure that our users have a great experience.

We'll talk about the role of testing, easy ways to make a web site perform as well as where Ajax can help give a richer experience.

By Nathaniel Schutta

Ah, that new project smell, it's intoxicating! Full of hope, we trek off in pursuit of technical greatness. In this talk, we'll cover some of the important first steps of a new project including continuous integration, creating a testing culture and establishing low ceremony process.

Ah, that new project smell, it's intoxicating! Full of hope, we trek off in pursuit of technical greatness. In this talk, we'll cover some of the important steps of a new project including continuous integration, creating a testing culture and establishing low ceremony process.

By Nathaniel Schutta

Watch Preview Video

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

By Ken Sipe

This session is a quick look at all aspects of being a corporate software architect. Whither you are a developer looking to move into the role of architect, needing to have an understanding of what is expected or already in the role of software architect looking for new and interesting ideas, this session is for you.

This session is designed to be a jam session on all aspects of software architecture and many of the roles of software architect. The following subject areas will be covered:

- Software Development Process

- Project Key Mechanisms: Languages and Frameworks

- Security: Threats, Securing Code Review, Adding Security to you process

- Layers, Partitions and Topologies

- VM Optimizations

- Usability and User Experience

- Optimizing the Web

- Ready for Production: Monitoring

- Integration

- Data Modeling

By Ken Sipe

So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.

Combined with proper JMX instrumentation, the need to bounce the server may be eliminated for all but the rarest of cases.

This session will look at the Java 6 monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. In addition to what is provide in the JDK, a number of freely available management tools will be demonstrated.

By Ken Sipe

Thoughts lead to words, words lead to action, actions lead to habits. In this session we'll sharpen the development saw in the process of understanding what makes a hyper-productive programmer. The focus will consist of developer habits and development processes.

As described in the book "7 Habits for Highly Effective People", there are habits which are characteristic of highly effective people. Clearly there are hyper-productive developers which distinguish themselves from the development pack? what is it that makes the difference? What are the habits and practices of highly effective developers?

This session will focus on individual developer habits, as well as team practices and the processes which result in high quality running software.

By Ken Sipe

The agile focus of software development puts heavy focus on user requirements through user stories. However we can not lose sight of the non-functional requirements as well. The software could be written to the exact specification and desire of the user, however if it takes 5 minutes for a request response, or it only supports 2 users or it isn't secure, then we still haven't done our jobs as developers.

This session will focus on the non-functional requirements of software development, namely: Performance, Scalability, Security, and Software Monitoring and Management. Each subject area discussion will include, goals, design practices, tools, and where it fits in the software development life-cycle.

By Ken Sipe

The Spring Framework has led the industry in innovation for years. Starting with dependency injection and promoting testing through removal of framework dependencies. Spring 3.0 continues that innovation in a way that takes full advantage of the Java 5 platform. There are a number of significant changes to the framework. So whither you are new to the framework or an experience Spring developer, this is a great session to come up to speed on the latest from SpringSource.

This will cover all the new features in Spring 3 complete with demos. This will include a look at the following:

- Spring MVC

- Spring REST

- Spring EL

- Spring Portlet

- Spring Declarative Validation

Prerequisite: Java 5

By Ken Sipe

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

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

By Ken Sipe

A live Hacking demonstration exposing the tools and techniques used by Hackers.

A look at the growing space referred to as ethical hacking or penetration testing. We'll look at example attacks which include:

Client-side exploits

Sql-Injections

Brute force attacks

Man-in-the-middle attacks

Key logging

By Brian Sletten

There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.

If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old

By Brian Sletten

If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.

The Restlet API was created by a guy who wanted object-level support for RESTful concepts, but didn't want to make the move to an advanced resource-oriented environment like NetKernel. He wanted his REST and conventional environments too. He also wanted a path to more modern containers that aren't tied to a blocking I/O model like the Servlet spec is.

This talk will include a brief review of REST and its primary concepts and will then provide an introduction to the Restlet API and how it supports these ideas. It will then focus on standing up a REST-oriented infrastructure using the Restlet API and a variety of other open source tools to support a publish/find/bind infrastructure without to

Prerequisite: REST (unless you are very comfortable with REST)

By Brian Sletten

The goal for web services was always to reduce our burden by increasing the potential for reuse of business functionality. Somehow, we got lost along the way in a morass of confusing, unfulfilling and downright broken technologies.

While we are interested in pursuing REST-based systems for managing information, we need some strategies for tying it all together sensibly. If we abandon WSDL, SOAP and UDDI, what do we replace them with? This talk will walk you through combining resource-oriented strategies with technologies from the Semantic Web to describe, find, and bind to services in dynamic, flexible and extensible ways.

We will start to blur the distinction between data, documents, services and focus on information and how it is connected to what we already know.

This talk will introduce you to strategies for building on individual REST services to produce a well-described, dynamic, discoverable fabric of services that can be used in a variety of scenarios including:

finding data sources

finding transformation services

orchestrating these sources and services in reusable ways

publishing discoverable services

Prerequisite: The Semantic Web: The Future Now, Give it a REST and SPARQL : Querying the Data Web would all be helpful talks to have attended

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 encompas

By Brian Sletten

If you have come to the NetKernel overview talk and came away compelled but unsure how to proceed, this talk will jump right in to building real resource-oriented systems with NetKernel. We will move away from the theoretical mind-melting right into the applied mind-melting. It is difficult to make the shift away from an object-oriented model, but this talk will demonstrate several examples of how and why you may want to. It will also include a preview of what is coming in NetKernel 4. This is kind of a REST + Polyglot Programming + SOA + Architecture talk all rolled up into one.

This talk will build out:

Wrappers around a relational database that can act as RESTful interfaces through HTTP or service higher layers

Transformational layers that convert the data into different forms

Orchestration across a variety of data sources

Integration with a variety of web tier technologies

All along the way, we will make appropriate language choices to solve our problems. One size does not fit all and an environment that embraces this is incredibly important.

Prerequisite: Intro to NetKernel : Software for the 21st Century, Give it a REST (if unfamiliar with REST)

By Venkat Subramaniam

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.

In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

By Venkat Subramaniam

Domain Specific Languages (DSLs) are languages targeted at a particular problem and domain. They have context and are fluent. They help users of applications at various levels to easily communicate with your application. Developing DSLs, however, are not easy. You could easily get dragged into using parsers and tools with steep learning curve.

In this presentation, we will look at various options to create DSLs on the Java platform. We will focus on external DSLs–these give you the absolute flexibility to chose syntax, but involve the most work as well. We will look at various tools and techniques that can ease this development effort.

By Venkat Subramaniam

Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you.

In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.

By Venkat Subramaniam

Groovy brings the dynamic productivity to the Java platform. One of the strengths of Groovy is the seamless integration with Java–it preserves the Java semantics. However, Groovy does have some differences that can surprise you if you're not expecting.

In this Jeopardy style presentation, you will pick topics you'd like to discuss and we will understand the strengths and differences Groovy brings in those areas.

By Venkat Subramaniam

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

Patterns overview

Implementing common patterns in Groovy

Beyond Gang-of-four patterns in Java and Groovy

Lots of examples

By Venkat Subramaniam

How is testing done on agile projects? Do we need testers when programmers can write tests? When do we do test? If the requirements are evolving, should we postpone testing until they stabilize?

This presentation will address how you can approach testing in agile projects. We will discuss the role of programmers and testers in testing, the tools and techniques they can use. We will discuss when testing can start and how it can proceed. This session is intended for both programmers and testers who are actively involved in agile projects.

By David Bock

Most good developers eventually have the opportunity to be managers. Whether they call you the "project manager", "Technical Lead", "Lead Developer", or some other classic middle-management title, you become the 'goto' guy between management and developers. You're the guy who is expected to keep the project in-line, track a schedule, and occasionally answer the question "How's it going?", and perhaps still contribute at a technical level. So how do you do that?

So what do you do next? How do you plan what needs to be developed? How do you know if you are 'on schedule' or heading off-track? Using good ideas from a bunch of successful projects (but no methodology in particular), you will learn the basics of good project planning, execution, and tracking.

While this talk as management methodology agnostic, many of the ideas are tracable directly back to concepts from XP, SCRUM, and even RUP and CMMi. Whether you are following a management methodology or not, the ideas in this talk will be applicable to technical managers.

By David Bock

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

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

By David Bock

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

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

By David Geary

This session introduces JSF 2.0 fundamentals, with emphasis on new features in JSF 2.0.

JSF 2.0 has been a long time coming, but now that it's here, it boasts an impressive set of improvements over JSF 1.X, including standardization of Facelets as the default display technology, a much richer event model, and built-in support for Ajax. Come to this session to see how you can use Java's standard web application framework to create industrial-strength web applications.

This session will cover the following features of JSF 2.0:

Resources

Using Groovy

System events

Bookmarkable views

Templating

Prerequisite: Familiarity with JSF, or other component-based frameworks

By David Geary

This session covers two of the most important features of JSF 2.0: composite components and built-in Ajax.

JSF is a component-base framework. Components are a powerful reuse mechanism, but they were rendered nearly inconsequential in JSF 1.X, because components were so difficult to implement.

JSF 2.0 makes implementing cusomt components easy with a new feature that builds on Facelets and the new resource capabilities in JSF 2.0: composite components. This session shows you how to implement your own components with JSF 2.

Additionally, this session covers the built-in Ajax that comes with JSF 2.0. Come to this session to see how you can easily implement custom components with integrated Ajax capabilities.

Prerequisite: Familiarity with JSF, or other component-based frameworks. Familiarity with Ajax. This session builds on the JSF 2.0 Introduction talk, so it is helpful, although not required, if you attend the intro talk before coming to this session.

By David Geary

An introduction to Flex for Java developers.

Want to develop expressive web applications? Them come to this session and see what Adobe's Flex is all about. Flex has lots of similarities to Java-based web development, so you'll find it easy to learn, and powerful to use. Come to this session if you want to take your web application user interface to the next level.

This session will cover:

An introduction to Flex

ActionScript, HTTPService, and data binding

Drag and drop

Components

View state

Integrating with Java back ends

Prerequisite: Familiarity with Flex and at least one other web application framework

By David Geary

Learn to implement web applications with GWT.

Google Web Toolkit lets you create killer Java-based web applications using familiar Swing and AWT idioms. This session will introduce you to GWT and teach you the fundamentals of using this cutting-edge framework for creating rich user interfaces that run in a browser.

For most of this session, and the session that follows--GWT fu, Part 2--I will live code a desktop-like, ajax-based, web application that illustrates the awesome power of GWT. In this session, I will cover the following topics:

Widgets

Remote procedure calls and database access

Event handling

Ajax testing

Prerequisite: Familiarity with a component-based framework, preferably a desktop application framework

By David Geary

Learn to do amazing stuff with GWT.

This session picks up where GWT fu, Part 1 left off. In this session, I will continue live-coding the Places application. In taking the Places application to its exciting conclusion, I will cover the following advanced aspects of GWT:

Dialog boxes

Sinking events

DOM elements

Working with HTML

Modules

Image loading and busy cursors

Event previews

Timers

In this session, I focus primarily on implementing a viewport widget in a custom module, and using that widget in the Places application. When I'm done, we'll have a very cool web application that shows the awesome potential of Google Web Toolkit

Prerequisite: GWT fu, Part 1 is not a prerequisite for this session, but it will help if you have some familiarity with GWT.

By Stuart Halloway

The Agile Manifesto, like any good scripture, admits of many interpretations. There is no one "right path." What works for us may not work for you. At Relevance we have tried many paths, and learned many lessons. Join us to see dozens of ideas that have worked for us, plus some that haven't.

The Agile Manifesto states four key values:

Individuals and interactions over processes and tools.

Working software over comprehensive documentation.

Customer collaboration over contract negotiation.

Responding to change over following a plan.

That manifesto sounds great, but perhaps a little vague. It gets more concrete quickly when you start doing it! In this talk, we will share our experiences, both good and bad, with various practices and problems associated with agile:

Pairing all the time (except when we don’t)

Running cross-project retrospectives

Code coverage standards

Choosing the sharpest tools

Fixed-bid projects

Handling budget problems

Teaching customers

By Stuart Halloway

Teams adopting agile should begin at a tactical level, but they shouldn't end there. The Agile Manifesto operates at many different levels. Learn to apply the principles of agile at a strategic level. Otherwise you can have a great agile ground game and still lose.

Many programming teams now embrace agile at the tactical level, which is the right place to begin. Applying the ideas in the Agile Manifesto, good teams embrace practices like

story point estimation

burndown tracking

technical expertise

behavior-driven development

daily standups

pair programming

continuous integration

spiking

refactoring

customer always available

well-understood roles

The Agile Manifesto can be applied at a strategic level, too. However, the tensions are different. Feedback cycles are longer, objectives and results are less clear, and roles and relationships are unknown or changing. In this talk you will learn how

By Stuart Halloway

If an iteration is the heartbeat of an agile development process, then Iteration Zero (IZero) creates the heart. While you can (and should) retrospect and adjust throughout the software lifecycle, few things are as valuable as a good start. In this talk, you will learn how we run Iteration Zero at Relevance.

The purpose of IZero is to prepare all stakeholders, so that Iteration One can begin normal iteration pace, heading in the right direction. In this talk, we will visit each of the four principles of the Agile Manifesto, and show how to establish them in IZero.

AM #1. Individuals and interactions over processes and tools. In IZero, you should identify the team roles, and find the right people to fill them. You should create places and times (both physical and virtual) to maximize contact and interaction.

AM #2. Working software over comprehensive documentation. In IZero, you establish the practices you will use to create working software, which may include test-driven development, pair prog

By Stuart Halloway

Find out why Clojure is Java.next:

• Clojure provides clean, fast access to all Java libraries.
• Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python.
• Clojure includes Lisp's signature feature: Treating code as data through macros.
• Clojure's emphasis on immutability and support for software transactional memory make it a viable option for taking advantage of massively parallel hardware.

Clojure is a dynamic programming language for the Java Virtual Machine, with a compelling combination of features:

Clojure is elegant. Clojure?s clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.

Clojure is Lisp reloaded. Clojure has the power inherent in Lisp,

but is not constrained by the history of Lisp.

Clojure is a functional language. Data structures are immutable, and most functions are side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.

Clojure simpli?es concurrent programming. Of course, Java itself has pretty good concurrency support. Bu

By David Hussman

Agility comes in many forms. While you may start out using XP or Scrum, long term success will mean finding a groove which fits your company. This session provides a path for adopting or adapting agility which draws on the strength of the successful practices being used.

If you are wondering how successful communities find a collaborative groove, this session has many answers and ideas for those interested in producing successful agile communities. Working in pairs and as a large group, you will take a stab at defining how you might produce, learning about your individual strengths and challenges. Everyone will leave with some collection of skills proven as useful guiding newly forming project communities as well as long running projects and their extended communities.

By David Hussman

If you are truly working to get value from agile methods, and you have been doing it for some time, you probably have some questions which go beyond "my first agile project". If you are looking for a place to get answers or hear where and how others are struggling, come to this session ready to ask your tough questions. I have coached many communities (of all shapes and sizes) adopt, adapt, and evolve agility beyond the first project or the first few months, and I am sure there will be no shortage of examples and experiences for you questions. Also, I am sure you will learn from others in the audience as well.

Going beyond big A Agile, we will start with some the common questions I see people facing who have long running or large scale agile projects. From there, we will prioritize the questions from the audience and take them one at a time. Any questions which go unanswered will be fodder for the agile BOF (if it follows the session).

By David Hussman

Being agile does not mean living life one iteration at a time. Agile projects without a long view can run into the common design problems of the past. Planning iteration by iteration is often foolish and feeds the myth that agile projects do not think beyond a few weeks. Successful agile projects plan within iterations and across iterations. The later planning is called release planning and it is the forum where agility first engages architecture and other cross cutting concerns.

Architects who think that agile projects evolve code one test at a time are only partially correct. Agile projects review and evolve architecture with unit tests, acceptance tests, architectural spikes, and continuous review of the system's ability to adapt and respond.

There is a home for architects and architecture on agile projects, and other traditional roles, but the there are some new variations. This session will talk about the relationship of agile methods and architecture and design and how they can work together to make stronger products and systems. The session will draw on information and anecdotes will come from projects of all sizes within companies of all sizes, including so

By David Hussman

Whether it was intentional or not, the agile community has been borrowing successful ideas from the lean manufacturing for years. Lean practices, like finding and removing wasteful work, can be applied without needing special permission or certification. Ideas like kanban (visual planning aids) and kaizen (continuous learning) are simple, helpful tools that are easily applied and produce great results.

This session will discuss how lean thinking has influenced agile methods and how you can use simple lean ideas to produce better software more often. We will not get stuck on wasteful discussions about "what is Scrum?" or "what is agile?" Instead we will talk about (and try - time permitting) a collection of useful lean practices and tools.