By Tim Berglund

Traditionally, business intelligence tools have been a high-cost part of any enterprise's software inventory. Recently, options have emerged that allow architects to build a credible business intelligence stack out of entirely open-source components. In this brief overview, we will demonstrate ETL, reporting, and analytics tool that can be deployed free or at low cost. Learn how to turn your company's transactional database into a rich data asset with a business-friendly user interface that integrates into your existing software infrastructure.

We begin this session talking about the differences between a transactional database and a data warehouse, describing the many benefits of creating the latter. Then we'll see how to take a transactional database and convert it into a warehouse star schema using the Eclipse-based Talend ETL. Next, we'll demonstrate how to enable business analysts to build reports with Jasper iReport, an open-source visual report designer. We'll talk about ways to integrate these report designs into your Java- or Groovy-based application. Finally, we'll look at more sophisticated options for analysis using tools from Pentaho.

This is a mile-wide, ankle deep view of an open-source business intelligence stack.

By Tim Berglund

Once you're familiar with the concepts of data warehousing, star schemas, cubes, and pivot tables, then it's time to dive in and look at how the tools really work. Continuing from the quick demos in Part I, this workshop session will have you building an actual ETL process with Talend Open Studio. This hands-on exercise will acquaint you with the tooling and solidify the concepts you've learned.

Be sure to bring a laptop (or pair with a friend who has one). You'll receive a VM image in "Learning Open Source Business Intelligence" if you attend it, or at the start of this workshop otherwise. This VM has all the tools we'll need pre-installed and ready to use.

Prerequisite: Learning Open Source Business Intelligence (or a solid grasp of BI concepts)

By Tim Berglund

Watch Preview Video

Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.

In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decision-making dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.

Software teams spend a great deal of time making decisions that place enormous amounts of capital on the

By Tim Berglund

Do your team's agile practices extend to the database? Agile methods are fairly well-understood as they apply to code, but these principles are not commonly understood or practiced on the databases that typically accompany enterprise software projects. Learn the tools, techniques, and mindset your team needs to make incremental improvements to the database’s design over time with confidence.

We'll cover Scott Ambler and Pramod Sadalage's vision of database agility as described in their book Refactoring Databases. We'll discuss the five-pointed constellation of evolutionary design, refactoring, automated testing, source control, and developer sandboxes, and how each of these practices contributes to successful database development. In particular, we'll look at how these practices are enabled by the open-source tool, Liquibase. We'll study a database badly in need of reform, select some refactorings from Ambler's catalog, and implement them in real time in a way that can satisfy the development team and the maybe even the production DBAs! This tool and the practices that animate i

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

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your project. I show how to produce projected graphs from dependencies, heat-maps for cyclomatic complexity and code coverage, using XSLT to extract visual information from XML configuration documents, and others. Metrics can't help you if you can't understand them. By creating visualizations, it helps leverage metrics to make your code better.

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your pr

By Neal Ford

Watch Preview Video

This talk covers testing the entire stack: unit, integration, functional, behavior-driven, databases, user acceptance, mocking & stubbing, and other topics and strategies.

Most talks you see about testing cover one particular tool, and rarely delve into the strategies around when you should use a particular tool for a particular kind of testing. This talk differs because it covers testing the entire stack: unit, integration, functional, behavior-driven, databases, user acceptance, mocking & stubbing, and other topics and strategies. I discuss the merits of "known good state" vs. "nuke & pave" for databases, discuss the differences between ClassicTDDers vs. Mockists and how they approach testing. Throughout, I provide strategies and heuristics to help guide you when making decisions about how, when, and why you are testing some part of your infrastructu

Prerequisite: Confusion about what to test when and where

By Neal Ford

Blacksmiths in 1900 and PowerBuilder developers in 1996 have something in common: they thought their job was safe forever. Yet circumstances proved them wrong. One of the nagging concerns for developers is how do you predict the Next Big Thing, preferably before you find yourself dinosaurized. This keynote discusses why people are bad at predicting the future, and why picking the Next Big Thing is hard. Then, it foolishly does just that: tries to predict the future. I also provide some guidelines on how to polish your crystal ball, giving you tools to help ferret out upcoming trends. Don't get caught by the rising tide of the next major coolness: nothing's sadder than an unemployed farrier watching cars drive by.

Blacksmiths in 1900 and PowerBuilder developers in 1996 have something in common: they thought their job was safe forever. Yet circumstances proved them wrong. One of the nagging concerns for developers is how do you predict the Next Big Thing, preferably before you find yourself dinosaurized. This keynote discusses why people are bad at predicting the future, and why picking the Next Big Thing is hard. Then, it foolishly does just that: tries to predict the future. I also provide some guidelines on how to polish your crystal ball, giving you tools to help ferret out upcoming trends. Don't get caught by the rising tide of the next major coolness: nothing's sadder than an unemployed farrier w

By Neal Ford

This talk describes an agile approach to architecture, and merges the current state-of-the-art thinking in both service oriented architectures(SOA) and web-based architectures like HTTP, REST, and hypermedia.

We're drowning in needless complexity in the enterprise architecture space: heavy, bloated tools, complex middleware, just-in-case architectural decisions, and vendor-itus. The side effect of all that complexity drives us further from our goals: architecture that is simple, free, supports business goals, loosely coupled, and evolvable. This session describes how to use web technologies (HTTP, REST, hypermedia, etc.) to implement robust, scalable enterprise architecture. This session shows a variety of different ways to attack this problem, with advantages and disadvantages for each, evolving towards the current state-of-the-art of REST-based architectures. This talk is based on original rese

By Neal Ford

Watch Preview Video

Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.

This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses

Prerequisite: understanding of architectural and design concepts

By Matthew McCullough

Watch Preview Video

This session will survey a wide range of tools across the Java space. We'll look at utilities such as VisualVM, jstatd, jps, jhat, jmap, Eclipse Memory Analyzer, jtracert, btrace and more.

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. The price of these tools eliminates barriers to their use and their open source nature allows you to mix and match them into compositions that work well for your application's unique debugging needs.

These tools will help you peel away layers of your application to expose bugs and performance ceilings. We'll interactively analyze the heap and garbage collection cycles of both local and remote applications, take snapshots of heap, query the heap for heavy usage, leaks and augment running code without a reboot and without breaking a sweat. After attending, you'll never look at Java debugging the same way again.

By Matthew McCullough

Watch Preview Video

Does your application transmit customer information? Are there fields of sensitive customer data stored in your DB? Can your application be used on insecure networks? If so, you need a working knowledge of encryption and how to leverage Open Source APIs and libraries to make securing your data as easy as possible. Cryptography is quickly becoming a developer's new frontier of responsibility in many data-centric applications.

In today's data-sensitive and news-sensationalizing world, don't become the next headline by an inadvertent release of private customer or company data. Secure your persisted, transmitted and in-memory data and learn the terminology you'll need to navigate the ecosystem of symmetric and public/private key cryptography.

By Matthew McCullough

Now that you have the basics of encryption under your belt, we'll advance to talking about where it is sensible and performant to add this level of security to your application. Symmetric key and public key encryption have various levels of processing overhead, so you can't blindly just use the "best" encryption out there. What about password hashes? Did you know they are vulnerable with our "salt"?

We'll look at the performance metrics, security strength and weaknesses of various encryption algorithms. Given today's global economy, we'll also talk about what strength keys can and cannot be used across national borders. Lastly, we'll look at protocol-wrapping encryption techniques, such as VPNs, as a solution to abstracting away this difficult area of programming into a higher level service or device. We'll end with a brief peek at quantum and elliptic curve encryption.

Prerequisite: Encryption Bootcamp on the JVM

By Matthew McCullough

No app is an island nowadays and your bleeding edge Java & JavaScript apps demand that you integrate with Facebook, Amazon, Gmail, Google Search, Twitter or S3 just to name a few. Make your next integration project a breeze by leveraging the successful work of others from the iBeans Central repository, or if necessary, simply author a new iBean and contribute it back for the benefit of all.

iBeans a new ultra-light service integration framework written in Java, but targeting both Java and JavaScript. It provides a centralized mechanism for community contributions of beans to the most commonly used services such as Twitter, Flickr, Gmail and more.

iBeans encourages the higher level programming at the level of integrating such web based services without worrying about the underlying protocols or communication mechanisms. Services are beautifully abstracted in the form of JavaBeans, with JavaScript capabilities added like a cherry on top of a confectionary masterpiece.

This talk wil demonstrate iBeans usage in a real world Java application and explore how easy it is to write and contribute a new bean to iBeans Central for the benefit of the community in true Open Source style.

By Matthew McCullough

Moore's law has finally hit the wall and CPU speeds have actually decreased in the last few years. The industry is reacting with hardware with an ever-growing number of cores and software that can leverage "grids" of distributed, often commodity, computing resources. But how is a traditional Java developer supposed to easily take advantage of this revolution? The answer is the Apache Hadoop family of projects. Hadoop is a suite of Open Source APIs at the forefront of this grid computing revolution and is considered the absolute gold standard for the divide-and-conquer model of distributed problem crunching. The well-travelled Apache Hadoop framework is curently being leveraged in production by prominent names such as Yahoo, IBM, Amazon, Adobe, AOL, Facebook and Hulu just to name a few.

In this session, you'll start by learning the vocabulary unique to the distributed computing space. Next, we'll discover how to shape a problem and processing to fit the Hadoop MapReduce framework. We'll then examine the incredible auto-replicating, redundant and self-healing HDFS filesystem. Finally, we'll fire up several Hadoop nodes and watch our calculation process get devoured live by our Hadoop cluster. At this talk's conclusion, you'll understand the suite of Hadoop tools and where each one fits in the aim of conquering large data sets.

By Matthew McCullough

Explore what's new on the cutting edge release of Maven, version 3.0. We'll explore the performance improvements, features that make debugging Maven issues easier, and changes to POMs that may require modifications to your build, but will result in more determinate build outputs.

Maven 3.0 has undergone major refactorings, and correspondingly, a battery of backwards compatibility tests to ensure a smooth transition from Maven 2.0. These refactorings prepare Maven for the next several years of development, including the separation of the POM file language from from the POM in-memory processor, which is already leading to Groovy, Ruby and YAML based POM file parsers.

By Matthew McCullough

Cloud this, cloud that. It's all we are hearing about these days. And whether buzz-worthy or not, you need to get in-the-know so that you can talk effectively about how this could fit into the application strategy on your next project. Leverage 100s of hours of research distilled into a 90 minute presentation. Get bootstrapped with what cloud computing is and isn't, who the players are in this space, what unique features each offers, and then how Google is completely changing the game.

We'll navigate through a some demos of building and deploying an app live to the Google App Engine, and talk about the excellent tooling that the framework provides. Lastly, we'll put a reality check on cloud computing, and GAE specifically, looking at pitfalls and gotchas. You'll walk away having a thorough knowledge of cloud computing basics and the ability to build a practice app for GAE.

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

Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used.

In this presentation, we'll go over some basic functional concepts, then start seeing how they apply in the FJ library, and show how to use FJ and functional ideas on common Java programming tasks. Let the excuse "I can only use Java" finally be consigned to the rubbish bin, once and for all.

By Ted Neward

Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right?

In this presentation, we'll go over what's missing from the Java Collections library, what is provided via other sources (Google and Apache, among others), and what you can provide for yourself, including a brief foray into the world of functional programing, and how it can make your Java code more elegant.

Prerequisite: Busy Java Developer's Guide to Collections

By Ted Neward

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

By Ted Neward

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

By Michael Nygard

Is your system small, medium, large, or super-size? Is traffic on it's way up?

Architecture patterns and structures that work at one scale seldom work across all of them. A communication style that's appropriate for small websites will probably fail badly if you apply it to world-wide networks of computers. Likewise, structures that work for large-scale systems are probably too complex and expensive to be worth it for small sites.

In this talk, Michael will discuss the notion of "design envelopes" for architectures. He will explore several common scaling strategies and map them to different system scales.

During this session, Michael will present reference architectures for systems at a variety of scales. It's sometimes possible to scale smoothly from range to range, but it can be extremely disruptive if you don't plan for it.

Along the way, he'll also address the different dimensions of scalability problems: traffic, content, data volume, and operations.

By Michael Nygard

Servers, storage, networking, backups... they're all vanishing into the "clouds". Cloud Computing is the emerging architecture for massive, scalable infrastructure that your company doesn't have to own or operate.

In this session, Michael will discuss the ingredients of real cloud computing and how you can apply it to your applications. He will show several architectures and discuss applications that fit each of these models. Finally, he will also talk about some of the pitfalls and problems that cloud computing customers can encounter.

The term "Cloud Computing" can be applied to everything from Software-as-a-Service (formerly known as Application Service Provider) to virtual infrastructure, grid computing, and even remote backup services. Some of these make sense, but some are just bandwagon-jumping and buzzword bingo.

From the "zero servers" web startup to the corporate IT department battling server-sprawl, cloud computing has many manifestations. This session will differentiate among the various types of cloud computing and describe applicable use cases.

By Michael Nygard

Redis is one of the fresh crop of "NoSQL" storage solutions. It's a distributed key-value store that knows how to deal with data structures. Oh, and it happens to also be incredibly fast. Like, microseconds per write.

This session shows how to get Redis set up in standalone and replicated mode and how to start using it for persistence. It will also show some techniques to structure your data to achieve consistency without transactions.

By Michael Nygard

We're no longer working in a single language. Programming today is about both consuming and creating languages.

We've all heard a lot about domain specific languages (DSLs). So much so, in fact, that it seems like more people are talking about it than doing it. In this session, Michael will present a real domain with familiar problems. He'll then demonstrate both an internal DSL and an external DSL that solve the same problem. Along the way, we'll cover fluent interfaces, composing multiple DSLs, and the very cool parser combinators.

If you've ever left a DSL talk wondering when we're ever going to get past the "coffee ordering DSL" or the "Waffle House breakfast DSL", then you will want to see this session.

This session walks through the creation of a domain model with an internal DSL based on a fluent interface in Scala. Although this is not an introduction to Scala, the necessary Scala concepts will be covered sufficiently for anyone to follow.

After demonstrating the domain and the internal DSL, Michael will use parser combinators to build a grammar in just a few lines of code. This grammar will lex and parse the input files, along with constructing domain objects for further use.

Prerequisite: None.

By Pratik Patel

This session is aimed at helping developers get started with automating the collection of software quality metrics. We'll cover continuous integration, automated code metrics gathering, and analysis of these metrics. The ability to be able to detect problems early, and also to write higher quality code early, helps avoid bugs and headache down the line. We'll cover some best practices around using and putting in tools to help achieve higher quality.

This course centers around two freely available tools for maintaining high quality codebases. The first is Hudson, a continuous integration server. The second is Sonar, a code metrics server. In this session, we'll discuss best practices and then put them into use by setting up and running these tools. We'll also talk about tips for getting the most out of these tools. If you aren't using these tools in development, you absolutely need to come to this session - it will help make your life easier and impress your boss too!

By Pratik Patel

As with many technologies, the basics are easy. The hard part comes when the developer needs to do sophisticated integration, development, and testing as part of an enterprise application. A large enterprise application requires the developer to think of issues that affect the development, scalability and robustness of the application. This presentation will cover the advanced topics described below with a focus on the new persistence features in Spring 3.0 and JPA 2.0.

A large enterprise application often will have several sub-projects that each contain their own JPA persistence unit. This opens up a number of questions around how to organize the persistence units and how the code between sub-projects should interoperate. Developers will gain insight into these issues and will see a couple of solutions using live code examples.

Many enterprise applications require integration with an application server's JTA mechanism. JTA integration allows for JPA components to work with container managed transactions and distributed transactions. A typical usage scenario for JPA & JTA is this: read from a database using JPA, perform some business logic, put a mess

By Pratik Patel

We've all heard about virtualization for deploying applications. How about leveraging virtualization for development? In this session, we'll look at some time saving tips and build a virtual VM for development and testing.

Developer can make creative use of virtualization software like VMWare for development. In this session, we'll discuss how to create a virtual development environment and the benefits of doing so. We'll also look at several great ways to use virtualization for other development and testing tasks. Driven by demos and live usage of virtualization, the attendee will gain insight into virtualization and how it can be applied to make development tasks easier.

By Pratik Patel

So you have a great idea for an IPhone app, you've tried learning Objective-C, but it's just too hard. What about those other new platforms like Palm Pre and Android? Who wants to write the same app three times? Four times if you count Blackberry! Fear not, there is a much easier way for you to develop on the IPhone. Using a development style called "hybrid mobile applications" you can write apps for IPhone and other platforms using stuff you already know: HTML, CSS and Javascript. In this course, we'll go over the basics for hybrid development

This course outlines the basics of hybrid development. We'll cover the pro's and con's of this approach over writing native code for each specific mobile phone platform. Then we'll build an app and deploy it to an IPhone, all in the course of 90 mins - using simple technologies you already know: HTML, CSS, Javascript and JQuery. This isn't a webapp per se - it looks and feels and deploys just like a native app. You publish it to the App Store and people have to download & install it just like any other app.

By Nathaniel Schutta

Watch Preview Video

Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.

Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.

By Nathaniel Schutta

Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.

Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.

By Nathaniel Schutta

JavaScript is one of the most widely used languages around and yet its also one of the most misunderstood. With Ajaxified UIs becoming the norm, this humble language is once again at the forefront.

In this talk, we'll go beyond the basics of JavaScript delving into the mysteries of prototype inheritance, objects, language edge cases and the importance of testing.

By Nathaniel Schutta

Watch Preview Video

Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn't around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we'll read actual code discussing ways it could be improved. As we work through real examples, we'll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn't around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we'll read actual code discussing ways it could be improved. As we work through real examples, we'll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

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

Watch Preview Video

The agile development process is all about early and often feedback. One aspect of feedback is how is the team doing... Are we accurate in our estimates? Are we consistent in our velocity? As velocity varies, what is it telling me?

This session will focus on the art of estimating project stories and look at several techniques of assigning "points" to stories. We will discuss the advantages and disadvantages of the various approaches of point assignment. Regardless of the point system, the end result at the end of the iteration is a number... velocity. We will look at the value of velocity and contrast that with other feedback loops with the agile process.

By Ken Sipe

When it comes to cross cutting software concerns, we expect to have or build a common framework or utility to solve this problem. This concept is represented well in the Java world with the loj4j framework, which abstracts the concern of logging, where it logs and the management of logging. The one cross cutting software concern which seems for most applications to be piecemeal is that of security. Security concerns include certification generation, SSL, protection from SQL Injection, protection from XSS, user authorization and authentication. Each of these separate concerns tend to have there own standards and libraries and leaves it as an exercise for the development team to cobble together a solution which includes multiple needs.... until now... Enterprise Security API library from OWASP.

This session will look at a number of security concerns and how the ESAPI library provides a unified solution for security. This includes authorization, authentication of services, encoding, encrypting, and validation. This session will discuss a number of issues which can be solved through standardizing on the open source Enterprise Security API.

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

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

One of the greatest benefits of OSGi is its firewall-esque encapsulation of implementation details. The only traffic that gets in or out is the traffic that you explicitly specify; otherwise, all bets are off. The aspiring polyglot can bring in the right tool for the right job by hiding it behind OSGi services as an “implementation detail,” provided that only Java language types are exported.

This talk will:

give a brief introduction to OSGi and polyglot programming

explore the pros and cons of the polyglot OSGi approach

experiment with Groovy, Clojure, and Scala in an OSGi container

look at some of the “gotchas” one might encounter along the way

By Matt Stine

There isn't much said in typical Agile conversation about architecture and modularity. We will attempt to redress this omission by examining an agile approach to logical system architecture coupled with a potential implementation for the Java platform.

Tracer Bullet Development (TBD) is a technique that allows you to prove out the proposed architecture of your system by firing a "tracer bullet" through a vertical slice of your system that exercises all of its horizontal components. It has multiple benefits, including encapsulation, decoupled code, parallel code development, and more.

OSGi is a specification for a dynamic module system for Java with multiple open source implementations. It allows you to modularize your system into "bundles" which essentially firewall their own classloader space. Objects running within a bundle can only see types that they explicitly import and only expose types that they explicitly export. They interact with other bundles by expose and consuming services which are registered under a public interface.

At face value it seems that Tracer Bullet Development and OSGi are a match made in heaven!

In this talk, we'll examine the principles undergirding TBD, the pros and cons of this approach, and walk through the design of a system using TBD. We'll also get a brief introduction to OSGi and its various implementations, look at some of the tools available for OSGi development, and then implement our TBD design.

By Matt Stine

So you discovered agile software development this weekend. You've finally found the tools that you're going to use to fix your team. Do you rush in to work Monday morning with a slide deck in one hand and a baseball bat in the other, ready to bludgeon the first person who checks in untested code? How do you think that's going to work out for you? I can tell you from personal experience that it doesn't play out too well. There is a better way.

In this talk, we'll look at strategies for taking a guerrilla warfare approach to agile adoption. We'll walk through many of the agile practices and discuss how we can apply them on our own and still deliver value, including:

test-driven development on an island

guerilla continuous integration

personal kanban and other workflow practices

and more...

After we've gotten as agile as we can on our own, we'll show how you can infect your team and your boss with the agile bug by demonstrating the dramatic increase in your own productivity and code quality. After all, sometimes it's easier to ask for forgiveness than permission.

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

Java has come a long way, and yet there is so much that's happening in this space. In this presentation we will take a look at the exciting additions and changes coming up in the next version of Java.

Status of the Java language and the libraries

Features that are around the corner

JVM capability enhancements

Benefits of these imminent changes

Prerequisite: Good programming knowledge of Java

By Venkat Subramaniam

Groovy is a elegant, dynamic, agile, OO language. I like to program in Groovy because it is fun and the code is concise and highly expressive. Writing code in a language is hardly about using its syntax, however. It is about using the right idioms. Come to this section to pick up some nice Groovy idioms.

In this presentation you will take some Java code that does common operations and transform it to idiomatic Groovy. You will participate in exploring various options as you help transform several examples. Each example is intended to hone a particular idiom or Groovy facility.

Prerequisite: Some knowledge of Groovy is helpful but not required.

By Venkat Subramaniam

You can't be agile if your code sucks. You know that you have to constantly refactor your code and design. But the questions is how? In this presentation, instead of looking at a laundry list of refactoring techniques, we will instead look at how to effectively approach refactoring and along the way discuss some core principles to look for.

We will take some sample code and refactor it. As we refactor, we will measure the quality of code using continuous integration. You can pick up a list of refactoring techniques from tools. However, in this section you will learn how and when to drive those tools, and more important why.

By Craig Walls

Watch Preview Video

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.

It's been 8 years since Spring 1.0 was released. In that time it has gone from a modest open-source project to being a de facto standard Java application framework. Now, as Spring enters its 8th year, it continues its attack on Java complexity, packed with many new features such as:

First-class REST support

A new expression language

More options for annotation-driven bean wiring

Bean profiles

Declarative caching abstraction

Enhanced Java-based configuration

A new "c:" namespace

Unified property management

And much more

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for n

By Craig Walls

Watch Preview Video

In this example-driven session we'll see how to swiftly develop Spring applications using Spring Roo. We'll start with an empty directory and quickly work our way up to a fully functioning web application. You'll see how Roo handles a lot of heavy-lifting that you'd normally have to do yourself when working with Spring. And we'll stop at a few scenic points along the way to see how Roo accomplishes some of its magic.

In recent years, rapid application development frameworks such as Rails and Grails have earned a lot of attending. By employing code generation, convention-over-configuration, and the dynamic capabilities of their core languages (Ruby and Groovy) to offer unparalleled productivity, helping get projects off the ground quickly.

As awesome as these frameworks are, they do have one negative mark against them. Although developers love working with them, convincing the "boss" to build mission-critical applications in a relatively new development style based can be difficult. The mere mention of a word like "Groovy" conjures up images of tie-dye shirts and VW vans. Risk-averse project managers oft

By Craig Walls

Contrary to what you may have heard, OSGi is neither complex, nor heavyweight. In this session, I'll show you how OSGi can actually simplify application development rather than complicate it. We'll look at the benefits of modularity, the fundamentals of OSGi, and see how to develop basic OSGi bundles. We'll also see how a few gadgets in the OSGi toolbox can ease the development of OSGi bundles.

The secret weapon for attacking complexity in any project is to break it down into smaller, cohesive, and more easily digestible pieces. Unfortunately, Java lacks critical ingredients necessary to achieve true modularity.

Enter OSGi. OSGi is a mature and established framework for dynamic modularity in Java. With OSGi, you'll be able to realize true modularity in your Java projects, making them more flexible, comprehensible, and testable.

By James Carr

Good unit testing comes from testing the System Under Test (SUT) in isolation of the components it depends on to allow us to focus only on the behavior of our component and not have to worry about the added complexity of the other moving parts outside of it's bounds. However, the way that the SUT interacts with its collaborators is very important... we want to be able to specify these interactions as part of its behavior without violating encapsulation by either providing indirect inputs to the system or by verifying the indirect outputs.

Test Doubles allow us to specify examples for the SUT's collaboration with dependent components by allowing us to stub dependencies to return canned results, or record interactions with a dependency to verify the indirect output from the SUT.

A number of ways of using Test Doubles exist, whether hand rolling your own hard coded Test Doubles or using one of many popular frameworks. In this session, I will cover using Mockito to elegantly and expressively use all types of Test Doubles to aid in testing your objects in isolation as well as comparing how Mockito stacks up against other popular frameworks such as Jmock and EasyMock.

By Michael Easter

If you work with Java, chances are good that your project's build system is verbose and complicated. It is only natural: many of our build tools are verbose and complicated. For all the stunning advances in libraries and languages on the JVM, they are usually aimed at our projects, and not our builds. Despite being essential, the build languishes behind in technology.

Gradle is a nascent build tool that combines support for Ant and Maven with the fluidity and power of Groovy. From its strong documentation, to its advanced capabilities (e.g. multi-project builds), it is a bona fide contender in a brand-new era for build systems: an era where the build is treated as a first-class object.

In this talk, we'll take a tour of Gradle and provide you with the information you'll need to decide if this tool is right for your project.

By Brian Gilstrap

Until recently, REST as an architectural style has suffered from a lack of understanding and serious lack of frameworks. Now that APIs and frameworks like JAX-RS and Jersey are here, why should you take the time to learn how to build RESTful services?

Applying REST to your web services asks you to give up some very familiar and comfortable tools (session data, distributed transactions across services, etc.) and it may not be clear what you gain. This talk will explain why you can do more (composable services, flexible interactions, simplified caching, easier testing) with less (stateless interaction with the client, no distributed transactions, no servlets, optionally no container, etc.). Jersey, the JAX-RS reference implementation) is a great tool for building RESTful services and we'll use that to drive the discussion.

Not only will we discuss REST design, we'll explore a working example with a sample RESTful service built using Jersey

By Brian Gilstrap

Performance tuning/troubleshooting is the poor stepchild of software development. There are many reasons for this, and often it boils down to justifying the purchase of tools and the time to learn them. As a result, when problems occur we often end up struggling to find ways to get results in short timeframes and with much more attention on our activities than is good for finding and fixing problems. What if you could skip the PO process and still performance tune?

Open source performance tuning tools can help bridge this gap. They allow us the opportunity to gain the knowledge needed to investigate and solve performance problems without having to justify a purchase first. Sometimes they will be all that we need, and sometimes they will be a stepping stone to a more tailored tool. Both ways, they are invaluable.

In this talk, we'll explore many of the open source performance tuning tools available for Java. We'll look at usage patterns, kick the tires on some of the tools, and explore which tools make sense in which situations. This is the sort of information which, combined with some use of these tools while doing your development, will leave you in

By Dave Klein

You've heard about how easy it is to build web apps with Grails. Maybe you've even seen the simple CRUD app in a blink of an eye, but do you want to see what Grails is really capable of? Then join us as we walk through the construction of a real web application with this powerful framework. Along the way we'll see how to take advantage of Grails' features like GORM, service classes, custom tags, and URL mapping.

You'll be amazed at how quickly you can become productive with Grails, not just because of scaffolding but because of the power of “Convention over Configuration,” sensible defaults, and the dynamic goodness of Groovy - all applied to a suite of the best tools in the industry, such as Spring, Hibernate, Tomcat, Ant, Sitemesh, JUnit, and more.

Prerequisite: A general knowledge of what Grails is.

By Dave Klein

Representational State Transfer (REST) is fast becoming recognized as the preferred web services architecture in many situations. REST provides a loosely coupled way for applications to communicate with each other across the web. The simplicity and expressiveness of REST make it a perfect fit for Grails. Grails provides a full stack framework with which to build RESTful applications, complete with persistence, a transactional service layer, logging, security services, and more. Whether you're building applications for a service oriented architecture or just want to add some integration points to your standard web apps, you can relax and let Grails take care of the REST.

In this presentation we will look at:

- What REST is and what it is not

- How to consume RESTful services with Grails

- How to implement RESTful services in Grails

By Mark Volkmann

Clojure is a dynamically-typed, functional programming language that runs on the JVM and provides interoperability with Java. A major goal of the language is to make it easier to implement applications that access data from multiple threads (concurrency).

Clojure is a dynamically-typed, functional programming language that runs on the JVM (Java 5 or greater) and provides interoperability with Java. A major goal of the language is to make it easier to implement applications that access data from multiple threads (concurrency).

Soon Clojure will also be available for the .NET platform. ClojureCLR is an implementation of Clojure that runs on the Microsoft Common Language Runtime instead of the JVM.

Clojure might be for you if:

you're interested in making concurrent programming easier

you're open to branching outside the world of object-oriented programming to try functional programming

it is important for the applications you write to run on