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

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

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

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

The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.

This session will cover in detail a number of advanced metaprogramming concepts in Groovy. The discussion will cover using dynamic method interception, meta-class manipulation, AST transformations and Groovy's Metaobject-Protocol (MP) to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

By Neal Ford

Watch Preview Video

Most of the time when people talk about agile software development, they talk about project and planning practices and never mention actual development practices. This talk delves into best development practices for agile projects, covering all of its aspects.

Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development where an afterthought when writing software. This talk bills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.

Prerequisite: Having worked in an organization that values bureaucracy more than individuals

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

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

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

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

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

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

With the basics of Hadoop under your belt, we'll dig into the depths of this amazing framework by writing our own reducer in Java and deploying it to the cluster. Next, we'll dig deeper into DSLs like Pig and its log-file processing cousin, Chukwa. Since grid topology is intentionally very opaque in Hadoop, we'll look at the benefits and how to achieve a properly tuned cluster with replication. Specific to HDFS, we'll tune the configurable parameters for storage redundancy and bucket sizes.

In the ultimate use case of using many Hadoop components in harmony, you'll find the need to have a centralized synchronization and coordination framework. Don't build these capabilities on your own though, as you might be tempted to do in a homegrown distributed system. Instead, leverage Hadoop ZooKeeper's ability to store small sub 1MB blocks of data that contain state, naming, and mutex information.

Prerequisite: Hadoop: Divide and Conquer Gigantic Datasets (Intro)

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

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

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

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

Prerequisite: Basic understanding of Subversion or similar version control system

By 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

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

Performance tuning any application is a black art that can consume much time. Fortunately, Java has many tools that can aid in this effort. There also are a number of basic tips that can help to analyze and fix performance problems. The Java memory model is usually something that you don't need to tune, but for high performance applications it is necessary to tweak. While there are a number of advanced things that can be done to performance tune an application, we'll discover that the simple, basic things are all that are usually needed to make your apps fly.

This session looks at how to setup and run an application with profiling tools and monitoring tools. We'll setup an application to run and put it under heavy load. While running, we'll interactively monitor it and look for problems and how to go about finding and fixing them. We'll also cover the basic issues you should look for when performance tuning.

We'll look at memory management and how to tune it appropriately. We'll also look at some of the Java 6 tools available to monitor performance and look at the JVM internals. We'll focus on the simple things that can be done right away and then look at some more advanced tweaks to identify and fix performance issues. Along the way, you'll lear

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

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

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

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

By Brian Sletten

RDF is one of the lower level technologies of the Semantic Web. We use it to describe and connect information on both our public and private Webs. Everyone enjoys using Dublin Core, FOAF, Creative Commons and other existing RDF vocabularies, but how do you go about writing your own? And why would you want to?

This talk will be an introduction to what goes into creating a domain-specific vocabulary that is usable by humans and machines alike. We will start from scratch to create a simple vocabulary that gets progressively more sophisticated and ready for use. We will also borrow terms from other vocabularies to show how you can extend concepts across domains where it makes sense.

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

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

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

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

One of the best ways to introduce Groovy to new projects and teams is to use it for Unit testing Java code. Using Groovy to unit test Java codehas several advantages. You can take advantage of its concise syntax for writing tests. Groovy's dynamic and metaprogramming capabilities can be exploited for mocking purposes.

In this presentation, you will learn tips and techniques to use Groovy to unit test both your Java and your Groovy code.

By Venkat Subramaniam

Functional Programming has been around for a while, but it is gaining popularity, especially due to direct support in languages on the JVM. Writing code in functional style is not about syntax. It is a paradigm shift. In this presentation, using examples from Java, Groovy, and Scala, you will learn how to write code in functional style.

We will start out discussing the elements of functional programming and then look at examples of some common operations and how you can implement those in functional style.

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

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

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 i

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

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 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 presentation, we'll explore all of the ways to do bean wiring in Spring We'll take a pragmatic view of each style, evaluating their strengths, weaknesses, and applicability to varying circumstances.

Over 6 years ago, Spring entered the enterprise Java scene, bringing a simpler development model rooted in dependency injection, the notion of assembling application components in a loosely-coupled way. With it, however, came a flood of XML configuration, required to declare how those components were to be assembled.

For a variety of reasons, XML has fallen out of favor with much of the development community. Now that there are other frameworks that offer dependency injection without all of the XML, some are suggesting that Spring's heavy use of XML has it destined for the scrap heap.

They don't know Spring.

Although XML-based Spring configuration is still available and still has a place

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.