Session Schedule

By Jeff Brown

Groovy is an agile dynamic language for the Java platform. The language and its libraries bring many things to the table to ease the process of building applications for the Java platform. This session provides a detailed run through Groovy with lots of code samples to drive home the power of the language.

Dynamic languages provide a lot of power and flexibility compared to statically typed languages. Groovy brings that power and flexibility to the Java platform in a way that is totally compatible with all of your existing Java code, tools and infrastructure. This session covers all of the fundamentals of Groovy and gives developers a whole lot of practical information they need to get started with the language.

By Jeff Brown

Dynamic languages bring a lot of interesting elements to the table for teams interested in doing Test Driven Development (TDD). Groovy lends itself very well to TDD and this session demonstrates many features of the language and its libraries that help teams build more testable systems and build better tests.

The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.

By Jeff Brown

Grails is a full stack MVC framework for building web applications for the Java platform. Grails makes web application development both fun and easy. This session covers all of the fundamentals of building web applications with Grails.

Businesses need rich web applications and developers want to be able to build those applications without the pain that usually comes along with doing so. Grails addresses these needs very well. Grails demolishes many of the pain points that Java developers have almost (not quite) become numb to after years of suffering. This session covers all of the fundamentals: Introduction To Grails Domain Objects Controllers GSPs Custom TagLibs GORM

By Jeff Brown

Grails makes web application development both fun and easy. This session dives beyond the basics to cover advanced details of Grails that bring the really exciting features to your applications.

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails that help get your applications through that last 20% that teams often struggle with.

Prerequisite: Grails - Agile Web 2.0 The Easy Way

By Scott Davis

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

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

This talk focuses on integrating Groovy with your legacy Java codebase in a way that wouldn't raise an eyebrow in the most conservative of organizations. We'll look at the dramatic reduction in line of code you can achieve by simply flipping your POJOs (Plain Old Java Objects) to POGOs (Plain Old Groovy Objects). We'll talk about calling Java classes from Groovy, and calling Groovy classes from Java. We'll look at Groovyc, the integrated compiler that manages Groovy/Java dependencies without a hiccup. Not once will I tell you to throw out the old in favor of the new. In each case, I'll show you how to integrate the new with the old. Don't throw out your Ant build scripts; mix in a bit of Gr

By Scott Davis

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

The bulk of this session focuses on metaprogramming with Groovy. We'll add new methods to classes at runtime -- even if they were originally implemented in Java, and even if they were declared final. (Thanks, ExpandoMetaClass!) We'll call methods that don't exist and avoid the dreaded MethodNotFound Exception. (Thanks, invokeMethod!) We'll narrowly scope our metaprogramming shenanigans using Use blocks and Categories, and then cast our changes to the wind such that every instance of a class gets our added juice. If you are happy taking the Blue Pill, this talk is not for you. You can continue using Groovy as a slimmed-down dialect of Java -- an 'After' picture to Java's 'Before'. If, howeve

By Scott Davis

Struts enjoys an unprecedented marketshare in the Java web development space -- 60%-70% according to most surveys. As newer, modern web frameworks come to the scene, very little attention is paid to the real costs of migrating an existing Struts application. This talk shows you ways to mix Groovy into a legacy Struts application, dramatically reducing both the lines of code and the complexity. We'll also introduce you to Grails (a Groovy-based web framework) whose URL-mapping capabilities allow it to replace your Struts application without breaking legacy URLs.

Grails is a modern Web development framework that mixes familiar Java technologies like Spring and Hibernate with contemporary practices like convention over configuration. Written in Groovy, Grails give you seamless integration with your legacy Java code while adding the flexibility and dynamism of a scripting language. After you learn Grails, you'll never look at Web development the same way again.

By Scott Davis

Groovy is a new dynamic language that dramatically speeds up Java development. Grails is a complete web framework in a box, including a web server and a database. Google Maps allows you to add maps to your webpage in a few lines of code. Put all three together and you are built for speed.

In this talk, Scott discussed how to incorporate Google Maps with your database-driven web application. Mashing up local data is one thing: mapping data from other websites like Google Calendar is just as easy. Groovy's XML parsing capabilities make dealing with web services a breeze. Creating mashup means understanding both web services and Ajax-based mapping services. This talk provided sound fundamentals in both. The rich toolsets out there allow you to spatially-enable data that you never thought of mapping.

By Neal Ford

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

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

By Neal Ford

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

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

By Neal Ford

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

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

By Neal Ford

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 session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.

Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This session describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This session also demonstrates some areas where it makes sense to mixin Ruby and Java code: Rails on Java, testing, and dynamic programming. JRuby is a powerful implementation of Polyglot Programming, and this session shows you how to leverage this cutting-edge concept. Session Topics:JRuby's originsCalling Java from RubyCalling Ruby from JavaLimitations and pitfallsExample usageRails on JavaTestingDynamic programmingThe

By Neal Ford

The Gang of Four book should have been entitled "Palliatives for Statically Typed Languages", because the recipes it provides are cumbersome solutions to the problems it poses. Using powerful languages makes the solutions in the GoF book look hopelessly complicated. This session shows how to solve the same problems concisely, elegantly, and with far fewer lines of code using the facilities of dynamic languages.

The Gang of Four book was actually 2 books: a nomenclature describing common software problems and a recipe book for solutions. The vocabulary they defined is still useful. The recipes are a disaster! Dynamic languages (like Groovy and Ruby) have powerful meta-programming facilities far beyond statically typed languages. It turns out that many of the structural design patterns in the Gang of Four book and beyond are much easier to solve with meta-programming. This session compares and contrasts the "traditional" approach of design patterns with a more nuanced meta-programming approach. Using language features creates cleaner abstractions with fewer lines of code and little or no additional s

By Neal Ford

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

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

By Neal Ford

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

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

By Neal Ford

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

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

By 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

Facelets is a combination of Tiles and Tapestry, and it's the hottest JSF-related open source project on the planet. It's popularity is well deserved, and in fact, much of what is in Facelets today will make its way into the JSF 2.0 spec due out in 2008. So not only can you come to this session and see some really cool demos that you can put to use in the real world, but you'll also be learning JSF 2.0 before it's even been defined! How's that for a ROI?

This session is 90 minutes of nothing-but-Facelets, so we're going to cover a good bit of ground. You'll see all of the basics, such as templating, error handling and debugging, and some of the more advanced aspects, such as creating your own components and tag libraries.

Prerequisite: Some knowledge of JSF is essential. If you're familiar with a templating framework, such as Velocity or Tiles, that's a plus, but not required.

By David Geary

The Google Web Toolkit (GWT) is truly a revolutionary framework that lets you develop Ajaxified web applications without knowing anything about Ajax or JavaScript. But the GWT goes way beyond basic Ajax by letting you implement desktop-like applications that run in the ubiquitous browser.

In this, the first of a two-part session on the GWT, you will learn about the framework and its fundamental capabilities, such as: rapid development with project and application generators; the GWT widget hierarchy; remote procedure calls; the GWT's history mechanism, including its integration with the Back button and bookmarks; and integrating JavaScript frameworks, such as Script.aculo.us, with your GWT applications.

By David Geary

In the second part of this talk, you will learn how to extend the GWT by implementing custom widgets, including a scrolling viewport and a drag and drop framework. After discussing custom widgets, you will see how to integrate database access into your GWT applications, and how to deploy your GWT applications to external servers.

You will also learn how to integrate GWT widgets into legacy applications built with web application frameworks such as Struts, JavaServer Faces, or Tapestry. The GWT is one of the most powerful Ajax frameworks on the planet, and one of the few that let you easily implement desktop-like applications that run in a browser, and because of that, it has gained incredible mindshare in a short period of time. Come to these two sessions on the GWT and see what all the buzz is all about.

By Brian Goetz

JDK 5.0 is a huge step forward in developing concurrent Java classes and applications, providing a rich set of high-level concurrency building blocks.

Prior to the release of JDK 5.0, the Java platform provided basic primitives for writing concurrent programs, but they were just that -- primitive -- and difficult to use properly. Building multithreaded applications on the Java platform's low-level concurrency primitives posed many traps for the unwary, and many developers were forced to reinvent the wheel by writing their own classes for thread pools, semaphores, and task schedulers. To help users create robust, scalable, and (most importantly) correct multithreaded applications, JDK 5.0 includes a rich set of high-level concurrency constructs, such as thread pools, semaphores, mutexes, barriers, and high-performance concurrent collectio

By Brian Goetz

The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support of multithreading. However, the Java concurrency primitives are just that: primitive. From them you can build many concurrency utilities, but doing so takes great care as concurrent programming poses many traps for the unwary.

Based on the principles in the best-selling Java Concurrency in Practice, this talk focuses on design techniques that help you create correct and maintainable concurrent code. Presented in the style of Effective Java, this talk offers bite-sized items for effectively writing concurrent code, divided into three categories: writing thread-safe code, structuring concurrent applications, and improving scalability. Writing thread-safe code: - Encapsulate your data - Encapsulate any needed synchronization - Document thread-safety intent and implementation - Prefer immutable objects - Exploit effective immutability Rules for structuring concurrent applications - Think tasks, not t

By Brian Goetz

What's the worst thing that can happen when you fail to synchronize in a concurrent Java program? Its probably worse than you think -- modern shared-memory processors can do some pretty weird things when left to their own devices.

Java was the first mainstream programming language to incorporate a formal, cross-platform memory model, which is what enabled the development of write-once, run-anywhere concurrent classes. It is the Java Memory model that defines the semantics of synchronized, volatile, and final. However, because the most commonly used processors (Intel and Sparc) offer stronger memory models than is required by the JMM, many developers frequently use synchronization and volatile incorrectly, but have been insulated from failure by the stronger memory guarantees offered by the processor architecture they happen to be deploying on. (The infamous "double checked locking" idiom is an example of this sor

By Brian Goetz

Performance myths about the Java platform abound, from the general "Java is slow", to the more specific "reflection is slow", "allocation is slow", "synchronization is slow", "garbage collection is slow", etc. Many of these myths have their root in fact (in JDK 1.0, everything was slow); today, not only are many of these statements not true, but Java performance has surpassed that of C in many areas, such as memory management.

In this class, we'll look at some common Java performance myths, identify where they came from, and explore the platform changes that have rendered them no longer true. Many common performance hacks don't actually help, and some can seriously hurt performance. The result is that clean code that follows common usage patterns generally shows far better behavior on modern JVMs than code laden with tweaks designed to "help" the JIT or garbage collector. More often than not, this well-intentioned assistance has the unfortunate effect of undermining many common JIT optimizations, resulting in slower -- not faster -- code.

By Ted Neward

Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to have some basic ideas about bug-tracking in your toolbox. Learn to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.

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

By Ted Neward

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

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

By Ted Neward

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

For a beginning to intermediate Java audience.

By Ted Neward

Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).

For an intermediate Java audience.

By Ted Neward

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

Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

By Ted Neward

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

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

By Michael Nygard

Cloud computing is taking the world by storm. Amazon's Web Services, EC2, and S3 provide completely virtual infrastructure, letting startup and existing companies create sites and web applications faster than ever before.

In this session, Michael will use cloud computing to create and deploy a fully-functional web site. You will learn how to create and run your own virtual infrastructure in the clouds.

It used to take weeks and months to stand up a new site. You had to buy hardware, rent (or build) space, rack, stack, and cable it, and then you'd finally get to start installing operating systems, databases, and so on. These days, none of that is necessary. You can run a real business on the net without ever owning anything. Best of all, you can be up and running in a single day. A day? Trivial you say? OK, we'll make it an hour and a half, with time for questions.

By Michael Nygard

The typical JEE application does not reach the fabled "five nines" of availability. Far from it. It's more like "double eights". Come see why enterprise applications and web sites are only serving users 88% of the time instead of 99.999%.

Part 1 of 2

The bad news: applications are more complex and error-prone than ever. Site development projects are really enterprise application integration projects in disguise. SOA portends far-flung interdependencies among unreliable services. Failures will spread wider and wider, reaching across your company and even crossing boundaries between companies. How do monumentally costly failures begin, develop, and spread? Can they be averted? Once you hit Release 1.0, your system will be living in the real world. It has to survive everything the messy, noisy real world can throw at it: from flash mobs to Slashdot. Once the public starts beating on your system, it has to survive--without you. Did

By Michael Nygard

What can we do about the dismal uptime of typical applications? We are asked to provide "five nines", but only reach 88%, on average. Come learn how to prevent the Stability Antipatterns from biting you. Apply these Stability Patterns to contain damage, recover from shocks, and survive disasters.

Part 2 of 2

In part 1, we looked at common sources of system failure: those commonly created structures that exacerbate problems. Now, we'll take on Stability Patterns that not only stop the antipatterns, but also add resilience to your system. Apply your new failure-oriented mindset to unchain yourself from the pager and save your company from embarrassing--and costly--disasters. These patterns combat entire classes of failure modes, making your system robust against even unforeseen problems. Books on design and architecture only tell you how to meet functional requirements. They help your software pass Quality Assurance. But painful experience has shown that "feature complete" is not even close to

By Brian Pontarelli

This talk covers the difficult subject of dependency management and uses the Savant open source framework to illustrate how to tackle some of the more difficult problems of dependency management. During this talk we'll cover the basics of dependency management, software versioning, compatibility, upgrading, and much more.

Dependency management is a difficult problem that all projects must deal with. As projects contain more dependencies and start leveraging tools that providing transitive dependencies, this task becomes even more difficult. There are only a few tools available that providing dependency management including Maven 2, Ivy and Savant. This presentation will use the Savant tool in order to illustrate dependency management and how to manage it. This talk will cover these topics: Dependency management Software versioning Compatibility Savant project files Dependency resolution Integration builds Full releases If you build software in any form and don't currently use dependency management or som

By Brian Pontarelli

This presentation covers the latest dependency injection framework named Guice. Guice was written by the developers at Google and makes dependency injection lighter, faster and easier to write. Attendees will learn how to dependency inject their classes using Guice annotations and modules.

Google's Guice is a new light-weight dependency injection framework that uses annotations and Java code rather than traditional XML configuration. Like most of the projects from Google, Guice is extremely fast and reduces latency when constructing new objects and injecting dependencies. Guice supports the most common dependency injection concepts that other frameworks providing, but in a type safe manner and without the XML. Attendees of this presentation will learn how to setup dependency injection using Guice. This will cover a detailed description of Guice modules, which are Java classes used to configure Guice. It will also cover these topics: How Guice uses annotations to inject clas

By Jared Richardson

Technical debt has long been recognized in technical circles for years, but convincing your manager to budget time to repay "technical debt" has always been problematic. Let's couch the term technical debt concept in language more familiar to our managers: credit card debt.

Like credit card debt, technical debt accumulates slowly over time, and usually takes just as long to pay off. The interest slowly builds up until you're no longer able to pay off the principle: your entire development cycle is devoted to just "paying the interest". We'll examine common types of technical debt and strategies to effectively communicating the problems, and their solutions, to your managers.

By Jared Richardson

There are a number of great techniques you can use across technologies and projects. Come hear some of my favorite ways to move "beyond" and contribute a few of your own. We'll discuss topics ranging from glue languages to ditching your IDE to building your brain.

In this session we'll discuss: - Move beyond tools - Glue languages - Inbox Zero - Learning to learn - Not being a cog anymore - Macro Object Orientation - Clean code - Looking smarter than you are - Open source tool stacks - Tighter feedback loops - Scripted deployments - Scripting databases - Virutalization And more...

By Jared Richardson

Software projects fail over and over for many of the same reasons. We'll look at some of the more avoidable problems and some solid ways to fix them, or avoid them in the first place.

We'll talk about discovering what went wrong (and what went right!) with your last project, solving code integration issues, resolving lingering quality problems, establishing automated test suites, reining in soaring project requirements and more.

By Jared Richardson

An agile team is first and foremost "a team". When that gets lost in the rush to get a product out the door, the people suffer as well as the products. It's bad for the company, but even worse for the team members. We'll learn how to defuse some of the more common problems you'll run into on dysfunctional teams.

Restoring trust and providing visibility is hard once you've been burned. It's not always possible, but we'll examine concrete steps you can take to start rebuilding your trust and your team.

By Jared Richardson

An overview of the Agile software approach from the book Ship It! A Practical Guide to Successful Software Projects.

This book provides a comprehensive look at the software life cycle and can be used to retool the way you, and your team, builds software. While we can't cover the entire book in nintey minutes, we can look how a holistic view of the software life cycle helps you improve your projects and makes your life easier.

By Ken Sipe

Well the standards created EntityBeans.... yea. and the community created Hibernate. Fortunately the standards body learned some lessons and created JPA. JPA requires a vendor implementation and none make a better choice then Hibernate. Combined with Spring this trio is a powerhouse when it comes to developer productivity on applications requiring persistence.

This session will look at in detail the persistence capabilities of the latest Spring 2.5 and how to provide data access capabilities, including nicely added features for unit tests. We'll focus the persistence discussion on JPA and examine a number of ORM mapping scenarios and how JPA maps to them. We'll focus on the spring integration including transactional capabilities.

By Ken Sipe

Spring 2.5 is brand spanking new, with a number of fantastic features. With growth of large and complex Spring applications which struggle with xml manageability and with the added pressure of Guice and SEAM there is a push for less XML, with solution leaning towards annotations. Spring 2.5 adds to the toolset provided in Spring 2.0 to provide a development environment where XML is greatly reduced... or eliminated if you so choose.

The session walks through the new Spring 2.5 enhancements, then dives deep into annotation oriented injection. The demonstrations include standard applications as well as a look at the new Spring MVC.

By Ken Sipe

Looking to get into the portal development space. Looking to accelerate your development and leverage your existing Spring knowledge. This session will combine the 2 in one presentation showing several demos along the way.

This session provides 2 introductions in one. The first is a walk through of JSR-168 Portal development. With a look at several portal frameworks. The second is a look at the new Spring 2.5 annotation style of MVC and how it applies to portal.

Prerequisite: Spring

By Ken Sipe

Scale... what is scale... how do you applications that are scalable. How do you know if the application scales?

This session will look at server topologies and state management and how it affects scale. We'll detail a number of metrics to know and observe. In addition tools of the trade will be demonstrated such as jmeter.

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

SOA... Is it hype? What's real... and what's not? What is the right abstraction level?

The purpose of this session is to challenge the practicality of SOA and discuss the questions that we need to answer about service oriented techniques, practices and tooling. What is the right abstraction level for a service? Where does PBEL fit? When is an ESB appropriate or not? Everyone seems to be blindly accepting the enterprise needs an ESB or SOA. This session will focus on the facts of software development and the challenges which exist today with SOA. Where are SOA techniques being abused? If you are interested in SOA this session is for you. If you are tired of the SOA hype this session is for you. Much of the discussion will stem from experienced based principles of softwa

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

You're a good Java programmer. You understand the JDK libraries and how to use them. The problem is that many fundamental APIs don't take the bigger performance picture in mind. Garbage collection can end up killing your app if you aren't careful. Concurrency problems and contention can keep your well-intentioned software from leveraging modern hardware architecture that support multi-core and multi-cpu systems.

Who knew that simply using the standard library code the way it was designed was opening you up for performance problems in your apps?

Don't worry, Javolution has your back.

Javolution is a small (300K) API designed to bring many of the benefits of the Real-Time Java Specification (RTJS) to J2SE, J2ME, GCJ and CLDC through deliberate design decisions. It includes re-implementations of the java.util, java.lang, java.text, java.io and java.xml to demonstrate time-deterministic behavior. It also includes a framework for testing its own performance, supporting parallel computing, communicating with C/C++ applications and a real-time object to XML marshalling framework. Come see how you can get some of the time-determinism and concurrency benefits in either your client or server side applications. This is a fairly deep talk and is largely a decomposition of an API

By Brian Sletten

How well do you understand the dynamics of your applications? In our systems, we detect when simple things happen. Customers log in, people buy things, a stock is sold at a particular price, inventory shifts locations... all of these events mean little things, but what about the larger picture? Complex events are particular patterns of simpler events that suggest something deeper is happening. Do you know how you'd discover these bigger picture occurrences? Come hear how the Esper open source software represents a new class of complex event processing (CEP) frameworks that can be added to even high volume, high transaction systems.

Trying to write software to track event occurrence is difficult to do correctly and almost impossible to do efficiently. The problem is that the higher volume and performance our systems get, the harder it becomes and the more important it is to highlight interesting or unexpected activity that isn't represented simply by a log entry. Complex Event Processing (CEP) and Event Stream Processing (ESP) systems are emerging as a new strategy for processing and detecting complex sequences of more rudimentary events that could have bigger implications to your production systems. While commercial software is starting to add this behavior, Esper represents one of the most accessible and widely-used

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

You've read the articles, the books, the Ph.D. thesis and all of the meta-commentary about building RESTful APIs, but you're still not sure where to begin.

This is an interactive session and has almost no slides. You should come prepared to discuss ideas and maybe pair program with me and everyone else in the room. Bring your ideas for open source projects that we might want to expose through a resource-oriented model. Bring your concerns about your domains that you are convinced don't fit this model.

This is not an introduction to REST. If you do not know anything about REST, please come to the "Give it a REST" talk if that is offered as well. If not, we can have a quick review, but this session is more for people who want to talk about how the ideas apply.

By Venkat Subramaniam

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

What's DSL? Characteristics of DSLs Types of DSLs Designing DSLs Groovy features that enable DSLs Examples of DSLs in Groovy Creating DSLs in Groovy

By Venkat Subramaniam

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

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

By Venkat Subramaniam

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

Characteristics of quality code Metrics to measure quality Ways to identify and build quality

By Venkat Subramaniam

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

Java features Set of tricks Tips to improve your Java code