By Peter Bell

The easy part of implementing Domain Specific Languages is coding them. The hard part comes when you have to think about testing, documenting, evolving and providing appropriate editing interfaces for them.

In this session we'll go beyond the syntax and look at the real world engineering concerns for widespread use of a DSL and various proven strategies for building DSLs that will grow with your projects and work for your target users.

By Peter Bell

Eventually if you do a lot of work with DSLs, you'll need to consider using external DSLs to make your languages more flexible and powerful.

In this session we'll look at some of the best tooling available for working with external DSLs and will look at the trade offs between the different approaches and how to choose (or build) the right tooling for your particular needs. We will look at ANTLR, the Eclipse Modeling Framework, JetBrains MPS and MetaEdit+, comparing and contrasting and looking at how you would go about building and sing languages in each.

By Peter Bell

Oh no, your DSL is actually popular. And of course, the feature requests keep come in. But what do you do to evolve your DSLs without breaking the existing models as your understanding of the domain changes radically over time?

This session will take a DSL and show examples of the four key strategies available: "fixing the API", "backwards compatibility", "versioning" and "automated evolution/checking" and the implications of each strategy on the best way to implement DSLs that are likely to change substantially over time.

By Peter Bell

What are the various options for building DSLs on the JVM and how can you choose the best one for your next project?

In this fast paced session we'll look at a range of techniques for building DSLs. From Java and Groovy expression builders to Scala metaprogramming, the strengths and weaknesses of XML for external DSLs and fully featured approaches to external DSL development such as XText and ANTLR. We'll also look at practical issues such as DSL evolution, and IDE support and the relative benefits of each approach for different types of problems.

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 line. Team members and leaders owe it to themselves to learn how to make them well.

By Tim Berglund

Watch Preview Video

Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines.

Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet—perhaps the most valuable piece of computing infrastructure of the present day—may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we'll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.

By Tim Berglund

You love Groovy and you're a believer in cloud computing. For a larger project you might choose Grails and hosting on Amazon EC2, but what if you want to take advantage of the nearly massless deployments of a cloud provider like the Google App Engine? You could make Grails work, but it's not always the best fit. Enter Gaelyk.

Gaelyk is a lightweight Groovy web application framework built specifically for the Google App Engine. In this session, we'll talk through the simple abstractions it offers, then show how easy it is to code and deploy a useful application to the cloud.

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. Through this whirlwind overview, you'll learn the basic principles of business intelligence, how to think architecturally about the components of a BI stack and how to integrate them into the enterprise, and what specific tools you can employ to get the job done.

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

Watch Preview Video

Games? What do games have to do with good business-oriented applications? Turns out, a lot of interesting little tidbits of user-interface, distribution, and emergence, found normally in the games we play, have direct implications on the way enterprise applications can (or should) be built.

Come to this session, find out some intriguing things about what’s going on in the game industry, but more importantly, how ideas from the gaming world can turn around and answer some thorny problems in the business world.

By Ted Neward

Watch Preview Video

Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)... it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.

After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.

By Ted Neward

Watch Preview Video

Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.

The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.

In this session, attendees will be split into small groups and given a "real world" business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate--the great architect has no need of tools, just their mind and the customers' participation and feedback.

By Ted Neward

Getting the most out of your hardware historically was a question of optimizing native code to take advantage of CPU instructions, and setting the right optimization flags on the compiler. Then, when Java came around, it became a matter of simply allowing Hotspot to do its thing. But as the rise of multicore CPUs has made its presence felt in the developer mindspace, so has the need to start writing code in a more parallel/concurrent fashion. Unfortunately, this is an area that most Java developers have historically tried to avoid (like the Plague), so it represents a huge “black hole” for most of them.

In this presentation, we try to lift the cover of the pit over the demons of parallelization, and start exploring some concurrency/parallelization patterns, not with the intent of producing reusable code riffs, but with the intent of giving attendees a good grounding on different designs of parallel processing that apply to more than just Java.

Prerequisite: Busy Java Developer's Guide to Concurrency (Parts 1 and 2) or equivalent education/experience

By Mark Richards

In the book "97 Things Every Software Architect Should Know" (O'Reilly, 2009) I wrote about the importance of design patterns as a useful means of communication between architects and developers. Equally important to patterns is an understanding of AntiPatterns - things that we repeatably do that produce negative results. AntiPatterns are used by developers, architects, and managers every day and are one of the main factors that prevent progress and success. In this session we will look at some of the more common and significant development and architecture antipatterns. Through coding and design examples, you will see how these antipatterns emerge, how to recognize when the antipattern is being used, and most importantly, how to avoid them. By attending this session, you will be part of a movement to reduce the AntiPattern catalog from hundreds of entries to only a few.

Agenda - What are anti-patterns? - Factors that cause anti-patterns - Common software and architecture anti-patterns

I have selected 7 of the most common anti-patterns I see continually in the industry and in my travels. We will be going into the details of each of these anti-patterns.

Prerequisite: None

By Mark Richards

Messaging is both a science and an art. Messaging is a science with respect to the mechanics of the JMS API and the syntax for sending and receiving messages. However, messaging is also an art when it comes to applying the JMS API to solve real-world problems. In this session I will review some of the more common use cases for messaging and show techniques for significantly increasing both the performance and scalability of messaging-based applications. Using ActiveMQ, you will see how to create embedded brokers, how to use asynchronous logging with Log4J and JMS, and how to significantly speed up your messaging applications. In this session I will also describe and demonstrate some emerging trends in messaging, including RESTful JMS (that is, JMS over HTTP) and also AMQP (Advanced Message Queuing Protocol). Come to this session to find out how much fun messaging can really be!

Agenda - Messaging Performance Techniques - Messaging Topologies - Embedded Messaging Using ActiveMQ - Using Messaging with Log4J for Asynchronous Logging - RESTful JMS (JMS over HTTP) - AMQP (Advanced Message Queuing Protocol)

Prerequisite: Some knowledge of JMS and Messaging in general

By Mark Richards

Apache Camel is a robust open source integration framework that handles routing and mediation tasks associated with enterprise integration. Camel allows you to quickly and easily route messages and integrate components in a distributed, decoupled manner. For example, using the Camel Java DSL, you can send and receive JMS messages in just a couple of lines of Java code. In this live coding session I will describe what Camel is, describe the overall architecture, show why it is useful, and demonstrate through live coding examples how to use the Camel Java DSL to write simple (and complex) routing logic. By attending this session you will learn Camel well enough to use it at work the next day.

Agenda - What is Apache Camel? - Understanding Camel's basic architecture - Configuring and Running Camel - Input Endpoints and Triggers - Message Enhancement and Transformation - Message Processing - Comparable Technologies and Future Direction

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

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

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

While your project might have nearly 100% code coverage on the server tier, many projects ignore testing the web layer. With more and more code being pushed to the browser, a lack of tests for the client code begs for trouble.

This talk will explore several testing options including Selenium, JsUnit, Crosscheck, JSCoverage, Watir, JSLint, JSSpec and others.

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

HTML 5 is an adventurous and confusing prospect that will help change the Web as we know it. It is being finalized as a standard but won't be fully supported by most browsers for quite some time. Companies like Apple and Google have already committed to it as the future of Web application development, however. There are a huge number of new features, updates and gotchas coming at us (including the proverbial kitchen sink!) so it is time to get prepared. This talk will walk you through the new bits and try to put it all into perspective.

Attendees will learn about HTML 5 and related specs including:

• New and deprecated elements
• Immediate mode 2D drawing w/ the canvas element
• Timed media playback
• Local storage and offline mode
• Bi-directional communication sockets to servers
• Messaging between documents
• Drag and drop support
• And much more!

There will be a lot covered but this should be accessible to anyone interested in Web development.

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 Java-based messaging. They want to make business-based technology decisions that lay a path to forward progress rather than paying for technological flux.

This talk will introduce REST and walk through why it is so important and makes such a difference. We will talk about REST API design, security, long-lived systems, content-negotiation, contract enforcement, when REST might not make sense, etc.

REST and the Web Architecture are the basis for many exciting things happening on the Web and within our organizations. You owe it to yourself to make sure you really "get it".

This talk should be accessible to everyone but is probably intermediate level.

By Brian Sletten

The human web is reasonably well in hand by now. We are getting pretty good at building systems that people find valuable and entertaining. We have not spent as much time concerned about our software friends. There is a ton a rich content available on the web that is too difficult to extract in automated ways using just XHTML, the meta tag and microformats. This talk will introduce you to some emerging technologies from the Semantic Web camp to enrich your web pages with useful information for both automated extraction and improved browsing experiences.

Meta tags and microformats are useful but will only get us so far. The Resource Description Framework (RDF) is the metadata substrate of the Semantic Web that will take us to the next level of machine-processability and the Web. It allows you to express fairly arbitrary relationships about people, places, things, and content in an open world way. It is trivial to mix and match terms, vocabularies, etc. and to have a rich expressive capability not bound by the limitations of the relational data model and XML schemas. GRDDL is a technology for generating RDF metadata from content on demand. This can include XML documents, XML-RPC requests, XHTML pages, etc. The content could include authorship information, geotagging, creative commons license information, the topic of the document, etc. RDFa allows us to be more explicit about the metadata by embedding actual RDF relationships in our content. With technologies no more complicated than the presentation markup we are already using, you can imbue any web tier with extra semantic specialsauce that will benefit your users as well as help link you into the emerging Web of data.

By Brian Sletten

The human-friendly Web is about nicely-formatted, accessible content for users to browse. There are emerging Data Webs (both public and private) that rely on technologies from the Semantic Web stack to link increasingly rich connections between various data sources. SPARQL and RDF are the main tools for expressing and using this connectivity. This talk will introduce you to one of these topics and the practical and accessible aspects of employing them on the Web and in the Enterprise.

Getting people to come to consensus on common models and schemas is usually the hardest part of any data integration strategies. These technologies help lower the bar on both the technical and social costs of stepping up your integration strategies.

We will explore:

• an introduction to RDF and the SPARQL query language
• the fantastically successful Linked Data project that connections billions of interrelated content
• how to include relational data in the mix
• how to include enriched Web pages in the mix
• how to build client-friendly applications on top of this information

By Matt Stine

Watch Preview Video

One of the first principles of lean software development is the elimination of waste. Shigeo Shingo identified seven types of manufacturing waste in his "A Study of the Toyota Production System." Later, the Poppendieck's translated these to seven wastes of software development.

The seven wastes:

• Partially Done Work
• Relearning
• Extra Features
• Handoffs
• Delays
• Task Switching
• Defects

In this session, we'll examine each of these wastes and look at some of their common manifestations, both in our coding practices and in our development methodologies. We'll also examine strategies for eliminating each of these wastes from our development efforts.

By Matt Stine

Watch Preview Video

Kanban. What is it? It is most certainly not just moving sticky notes around on a board. Far from that, it is a method for gradual, evolutionary improvement of existing software processes. That's right, existing software processes. There is no "Kanban Development Process." Think you're "doing Kanban?" Think again.

In this session we'll examine the byproducts of the "Kanban method" and its use of a WIP-limiting, pull-based mechanism for managing a software team's work. Next, we'll examine "A day in that Kanban life" in order to get our minds around how a Kanban system works. We'll then step back in time and examine the roots of Kanban in the lean manufacturing methods used at Toyota. We'll also walk through a little queuing theory to understand why Kanban systems work. Finally, we'll walk through Kanban thought-leader David Anderson's "Principles of the Kanban Method."

You'll leave this session equipped to start a Kanban change initiative in your team, along with the tools to make it successful.

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

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 Jeff Scott Brown

Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.

This session will cover all of these topics to demonstrate how powerful the Grails framework is and show how little effort it takes to build not just a simple toy application but also to build real enterprise web apps.

By Jeff Scott Brown

GORM is a super powerful ORM tool that makes ORM simple by leveraging the flexibility and expressiveness of a dynamic language like Groovy. With GORM developers get access to all of the power and flexibility of an ORM tool like Hibernate without any of the complexity.

This session will cover a lot of the GORM API from the developer's perspective as well as diving into some of the implementation details. Knowing how some of this works under the covers will give developers an opportunity to not only improve their productivity with GORM but also open up possibilities of using dynamic metaprogramming in other aspects of their application development efforts.

Prerequisite: Advanced Grails

By Jeff Scott Brown

This live coding session will demonstrate how the basics of Twitter can be built using Grails and JMS in less than 90 minutes. The fast paced and code-driven presentation will build a Twitter-like application from scratch using Grails and its rapid application development capability.

By bringing together Spring, JMS and Java persistence techniques, Jeff will provide advanced tips and techniques for constructing Grails applications that can be deployed on to the Java EE platform. This session goes well beyond building simple CRUD applications with Grails.

By Jeff Scott Brown

Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)

This session will cover Spring AOP in detail to demonstrate how easy it can be to leverage the awesome power of Aspect-Oriented Programming.

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

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

Keynote discussing the benefits and challenges of being a polyglot programmer.

Keynote discussing the benefits and challenges of being a polyglot programmer.

By Venkat Subramaniam

Scala is a very powerful hybrid functional pure object oriented language on the JVM. Scala is known for its conciseness and expressiveness. In this presentation we will look at some common tasks you do everyday in developing applications and see how they manifest in Scala.

We will look at the strengths of Scala from application development point of view. Rather than focusing on the syntax of Scala, we will focus here on Scala idioms and powerful Scala libraries to perform routine tasks.

By Venkat Subramaniam

Watch Preview Video

In this presentation we will take a quick walk though the issues with concurrency and how the solutions provided in Scala and Clojure help address those.

The gaining popularity of multi-core processors has rekindled the concurrency question: How do you effectively implement multithreaded applications on the Java platform? The familiar approach in Java is to create threads and to manage access to shared mutable state using synchronized locks. This approach to concurrency is fraught with hard work and uncertainties. Have you marked the appropriate methods synchronized, did you decorate the relevant fields volatile, did you properly construct the mutually exclusive regions of code, and is there a potential for deadlock lurking in the code.

In this talk you'll learn about alternate ways to tackling concurrency on the JVM. One approach is the functional way, along with an actor based model provided in Scala, to deal with immutable state. This removes the problem at the root, since data can't change there is no issue of contention to contend with. Another distinct approach, provided in Clojure, is to protect access to mutable data, not using locks, but using transactional boundary. The Software Transactional Memory brings database like transaction model to in-memory data. In this presentation we will discuss the pros and cons of these approaches and how to effectively apply them.

By Venkat Subramaniam

Once I got convinced about the benefits of TDD, I used it pretty extensively and consistently to drive the design and development of my code. So, it came as a surprise when I was trying to convince myself that those practices do not apply on a highly multithreaded code I was creating on a project. Thankfully, I set out to prove that TDD does not apply, but ended up proving myself wrong.

In this, zero powerpoint, all coding presentation, we will use TDD to drive the design and implementation of a multithreaded code. Along the way we will hit some road blocks, and learn techniques and practices that can break the barriers. If you have confronted the issue or have wondered about it, this presentation is for you.

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 nearly everyone.

By Craig Walls

In this session, we'll start with the basics of Spring MVC development, focusing on how to leverage the new annotation-driven model. With that foundation set, we'll continue by exploring the new features in Spring 3.0 and 3.1 to build RESTful web applications that can serve both human-facing content as well as resources that are consumed by machine clients.

From the very beginning, Spring has included Spring MVC, a web framework built around the Spring Framework. Originally based on a rich hierarchy of controller classes, Spring MVC served developers well, but began to look a little long in the tooth compared to other web frameworks.

Starting with Spring 2.5, Spring MVC took a major evolutionary step, breaking away from the rigid controller class hierarchy model to embrace a more flexible annotation-driven model. Often referred to as Spring @MVC, this new model has continued to improve with Spring 3.0 and Spring 3.1.

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 often think that free love may have been a big thing in the 70s, but it has no place in serious business.

If psychedelic frameworks are a tough-sell in your organization, then you can still feel much of the same productivity gains while developing Spring applications. Spring Roo mixes Spring and Java with a little code generation and a dash of compile-time AspectJ to achive a rapid development environment that resembles Rails and Grails. But instead of producing Ruby/Rails or Groovy/Grails code that may make your manager twitch, Roo produces Java-based projects that use the Spring Framework--which is already accepted in many organizations.

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

Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues (oh, my!). Fortunately, new functional languages that run on the Java Platform, such as Scala, have made concurrent programming easier.

An alternate approach is to implement concurrent processes using a resource oriented computing (ROC) platform. At the heart of this ROC platform is a microkernel that allows processing to scale linearly as more CPUs are added. Consequently, developers are freed from the complexity of Java concurrency and functional programming.

In this session, I will provide an overview of resource-oriented concurrent programming using 1060 Research’s NetKernel. I will then present examples that compare and contrast this approach against concurrent programming using Java and Scala.

By Jeremy Deane

An Enterprise Service Bus (ESB) provides a platform for service provisioning. The core capabilities that enable provisioning across an enterprise include addressing, routing and transformations. Addressing is the ability to specify the location of a service regardless of transport. Service routing defines a message path across a number of servers or nodes and message content transformations are implemented using XML technologies such as XSLT and proprietary adapters.

Resource Oriented Architecture (ROA) goes beyond RESTful web services and provides a more extensible transport-independent foundation. Furthermore, ROA pushes the integration functionality to the edge of the network (as a URI), translating into better service management and scalability.

In this session, I will explore the convergence of Resource Oriented Architecture and Enterprise Integration Patterns. I will then present a Resource-Oriented ESB and several service examples using 1060 Research’s NetKernel and Apache ActiveMQ.

By Tiffany Lentz

Agile techniques are often pigeon-holed as just applying to software projects and IT organizations. Agile techniques are a mindset more than a list of rules to follow and can bring efficiency and improvements to all areas of an organization.

This presentation will cover a case study of ThoughtWorks experience with a major bank and credit card company in the US and their application of Agile techniques. We will cover the process, outcomes and challenges of the Agile implementation.

By Tiffany Lentz

Is your Agile team running smoothly? How do you know? This answer is found in your iteration and your toolkit for constant team improvement! Comparing Iteration Management skills and tools to those of the Agile Project Manager, Scrum Master and Technical Leader roles, you will see that Iteration Management encompasses end to end activities of the iteration, which are crucial to unblocking your software production line and making your team a success.

This session will enable participants to employ critical and industry proven techniques that will improve a team’s processes immediately upon application. An Iteration Manager encompasses not just project management activities, but ALL activities of iterations, including: story writing, development, testing, facilitation, visibility, communication and metrics. The session will provide hands on, proven and critical techniques to successfully managing the inner workings of iterations.

By Tiffany Lentz

This session focuses on visibility of team progress and correcting team "bad smells" using Agile metrics. Since we use metrics to self-correct and sharpen the team, they are an integral part of each iteration and flow into release planning. We will discuss some of the How's and Why's of team metrics and review the risks that are inevitable when it comes to gathering metrics.

Examples that we will talk through are: Burnup, Velocity, Lean "Finger Charts", Efficiency/Availability, Utilization and Estimation Accuracy.

By Johanna Rothman

Have you ever waited weeks for one piece of functionality so you could release a large project? Have you been in the situation where the software is waiting for the hardware? Or, where the database admin held up the entire release because his work wasn’t coordinated with the feature-based teams?

Program management is the art of coordinating several sub-projects to a common objective. Until the parts are assembled into the whole, the parts have no value to the organization.

Agile approaches help manage risk for projects, and we can scale agile approaches to programs.

In this session, we will discuss several options for how to create a program and run it in an agile way. We’ll examine how to report and obtain status, how to create and maintain a coherent architecture, and how to coordinate teams who are focused on their sub-project deliverables to create an overall deliverable for the organization. We’ll examine the issues of how to organize the teams, synchronize iterations, and know when you are ready to release.

Whether you work in an organization that uses agile methods or more traditional approaches, you can learn new ideas about managing programs.

By Johanna Rothman

Feel as if you can't get anything done? More projects than time to do them? Crises out the wazoo? Then it's time to consider another approach: managing your project portfolio. You can organize your projects and and evaluate them without getting buried under a mountain of statistics.

Johanna will discuss how to collect all your work, decide which projects you should do first, second—and never. You’ll see how lean and agile approaches fit managing the project portfolio and how they make it easy. We’ll discuss how to tie your work to your organization’s mission and show your board, your managers, and your staff what you can accomplish and when. You’ll get a better view of the work you have, and learn how to make those difficult decisions, ensuring that all your strength is focused where it needs to be.

By Johanna Rothman

If you've been trying to change your organization so that your projects are more agile, you may have noticed several problems: it's difficult to have people such as product management, senior management, even functional managers work and manage in a way that makes sense for your agile project; you're working with other parts of a large program that isn't agile; you have a geographically distributed team; your management wants to know at the beginning when the project will end; or even that the project team does not share a common vision of what "done" means.

You are not alone. Johanna Rothman explores common organization, management, team, and individual team member issues, such as your stand-up meetings are sit-down-and-forever meetings, your managers still think multitasking is a good idea, someone (or the whole team) thinks overtime is a good idea, or you have unranked requirements. Learn to make the changes needed for agile more palatable and help people work with you in a way that helps your projects proceed.

By Johanna Rothman

Many software managers came to management through the technical ranks. Although they may have had plenty of technical training and mentoring, they frequently have to learn management skills the hard way, through trial and error. Johanna will describe some technical management tips and tricks learned through trial and error, focusing on software managers and their particular issues.

You'll learn about a manager's job, how to create an effective work environment, and how you can help people do their best work.

This presentation is good for agile and non-agile managers.