By Tim Berglund

It's a given that everyone hates the legacy application and wants to replace it. You're tired of the brittle, untested code, the outdated frameworks, the platform nobody cares about anymore. You want to apply current practices and the productivity gains of today's tools. Usually this is just a frustrated dream, but every once in a while, you actually get to do it. That's great news, but it raises a question: how do you...do that?

In this session, we'll walk carefully through the common issues that arise when tackling the enormous task of replacing a key legacy application with a new technology stack. We'll explore the technology, business, and people problems that can result, looking at specific technology solutions for a slow and careful migration of business-critical functionality off of one system and on to another of a very different kind. Bring your legacy migration questions for a great discussion.

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

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 it produce real results, cleaning up an area of development that is all too often left messy and uncontrolled. If there is a relational database in your life, you will benefit from this talk.

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

Prerequisite: Confusion about what to test when and where

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 research and development done by ThoughtWorks, and represents the current state of the art in building truly scalable enterprise architectures. This topic combines the subjects of service oriented architecture with web technologies to create a hybrid providing you with the benefits of both approaches. You can build robust, scalable enterprise architecture that allows individual applications to evolve independently and rapidly. This talk describes how to make SOA suck less

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 the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain. This talk shows lots of examples of how to make this concept work in your environment.

Prerequisite: understanding of architectural and design concepts

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

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

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

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

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

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

By Matthew McCullough

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

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

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

By 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

MongoDB is designed for problems without heavy transactional requirements that aren't easily solved by traditional RDBMSs, including problems which require the database to span many servers.

Like other document-oriented database systems such as CouchDB, MongoDB is not a relational database management system. The database manages collections of JSON-like documents which are stored in a binary format referred to as BSON.

Attendees will see MongoDB code, hear how it manages transactional integrity (using "eventual consistency"), and how to interact with the server outside of code by using MongoDB client tools.

By Michael Nygard

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

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

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

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

By Michael Nygard

If your software fails in production, nobody will care how great the development project was, or how well the system passed QA. Production operations, the domain of your systems' least-appreciated stakeholders, is where the rubber meets the road. Come learn how to build your systems to thrive in Operations.

We will explore the most critical foundations for success in Operations: transparency, control, deployments, and configuration.

Along the way, we'll see some of the organizational dysfunction that prevents smooth, successful operations. You'll learn what you can do today to avoid these dysfunctions, even if you've inherited a legacy of distrust between Development and Operations.

If you don't want to wear a pager for the rest of your life, this session is for you.

By Michael Nygard

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

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

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

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

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

Prerequisite: None.

By Michael Nygard

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

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

By Nathaniel Schutta

Watch Preview Video

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

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

By Nathaniel Schutta

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

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

By Nathaniel Schutta

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

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

By Ken Sipe

Companies have focused for years to solidify the back-end infrastructure in defense against hacking attempts. Most companies however are forced to open up many ports including port 80 (http) for users to access web applications among other resources. This has lead to web attacks growing to be the #1 classification of hacker attacks today. In this space Cross Site Scripting (XSS) is the #1 ranked vulnerability affecting a large number of sites. This evolution requires that the understanding of securing an application move beyond sys admins and incorporate all aspects of system delivery for the protection of a system and system resources.

This session will detail what XSS is, including a large number of vectors of attack. We will review information from several OWASP development guides, along with code review tips when focused on XSS. An enabling aspect of XSS is AJAX and in particular JavaScript, for which we will focus on techniques and frameworks to help secure the DOM. Attendees will learn the techniques necessary to help XSS-Proof their web applications.

By Ken Sipe

Watch Preview Video

This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.

We'll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, task definitions and dependencies, the benefits of plugins, deep multi-project support, runtime optimizations through partial builds and harvesting existing functionality through Ant and Maven integration as well as strategies for migrating from these build tools. We will demonstrate some of the innovative goodies that come with Gradle out-of-the-box, like smart incremental builds, the Gradle Daemon and the Gradle Wrapper. We show also many of the new features like Eclipse integration, Sonar integration, Heroku integration, C/C++ support and other new plugins.

By Ken Sipe

Watch Preview Video

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

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

By Ken Sipe

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

This session is designed to be a jam session on all aspects of software architecture and many of the roles of software architect. The following subject areas will be covered: - Software Development Process - Project Key Mechanisms: Languages and Frameworks - Security: Threats, Securing Code Review, Adding Security to you process - Layers, Partitions and Topologies - VM Optimizations - Usability and User Experience - Optimizing the Web - Ready for Production: Monitoring - Integration - Data Modeling

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

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

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

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

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

• finding data sources
• finding transformation services
• orchestrating these sources and services in reusable ways
• publishing discoverable services

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

By 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

Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming.

Part of what makes Grails so compelling is its really powerful plugin system. The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others. This session will dive in to that aspect of the framework with a focus on Scala and Clojure and will demonstrate what is involved in adding support for new languages.

Prerequisite: Advanced 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

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

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

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

By Craig Walls

Watch Preview Video

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

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

• First-class REST support
• A new expression language
• More options for annotation-driven bean wiring
• Bean profiles
• Declarative caching abstraction
• Enhanced Java-based configuration
• A new "c:" namespace
• Unified property management
• And much more

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

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

Writing tests is more than just writing JUnit test cases and hoping that they'll pass when your project is built. If you want assurance that your code is sound and provides the desired functionality, then you'll want to test it from every angle and run those tests as frequently as possible.

In this session, we'll look at a few testing tools that you may not be all that familiar with, including:

• Infinitest : A continuous testing tool that reports test failures almost as quickly as you can break them.
• Mockito : A relatively new tool for mocking objects in tests.
• Concordion : A framework for writing FIT-like functional specifications, without the hassles of FIT.
• jqUnit and JSTester : A xUnit-like framework for testing JavaScript.
• Selenium : A framework for in-container testing of web applications.

If you're ready to elevate your testing prowess to the next level, come see how these tools can help.

By Robert Fischer

The power of multicore machines and cloud computing is all dependent on an application's ability to successfully leverage concurrency. Although concurrency has traditionally been considered fatally difficult in Java, a few simple architecture principles can make all the difference. This session will review some of those principles in both theory and practice.

This session will review the theory of concurrency and the different levels that concurrency will act on. With that basis, it explores the theoretical reasons behind the difficulties in writing concurrent code, and then some practical application architecture techniques to cope with those difficulties.

By Robert Fischer

JConch is a library that provides a few high-level tools for high-concurrency environments on the JVM. The java.util.concurrent package in the Java standard library provides low-level structures for managing concurrent communication. Learn here how to use both of them in order to produce clean, highly-concurrent, and highly-tunable code.

Programming in a concurrent fashion is quickly becoming mandatory for applications. This session will explore the best ways to do that on the JVM.

By Robert Fischer

The Groovy language now provides substantial concurrency capabilities via the GPars library, including the ability to work with actors and dataflow concurrency. This talk shows how you can integrate these Groovy concurrency structures into your Java applications.

The GPars project offers developers new intuitive and safe ways to handle tasks concurrently, asynchronously, and distributed by utilizing the power of the Java platform and the flexibility of the Groovy language. With GPars, Java programs can transparently leverage multiple cores and even multiple systems by moving through a layer of Groovy code.

By Robert Fischer

Increasingly, people are adopting Agile practices a la carte, and some are even talking about "post-Agile" methodologies. If things are going to be changing, let's take a moment to review Agile development practices, the problems they were trying to solve, what worked, and what difficulties these new methodologies are responding to. With this information in hand, we can make an intelligent decision about the development methodology for our team.

This interactive session will review the why's, wherefore's, and why not's of test-driven development, continuous integration, iterations, "point"-based estimation, retrospectives, scrums, and other Agile practices.

By David Hussman

What stops you from delivering to your customers and what truly prevents incremental learning in your project community? How much of it lies in coding issues? Do you even need to write code to learn where to go or how to get there?

For many companies, being agile means producing working code from an iteration. While working code is a measure of progress, and provides a tool to validate success, it is not always your best investment. Your best investment lies in combining 1) what helps you learn about your product and your market and 2) what you need to do to deliver it, and what is constraining either of these.

Using ideas taken from successful agilists, Theory of Constraints and the Lean Start up Community, this session will challenge you to think about what truly stops you from producing what is valuable when.

Will we use techniques that examine delivery and development constraints that start at product ideation and end with real user feedback? Along the way, we will discuss how agile methods can help and hurt your ability to build the do the right thing at the right time.

By David Hussman

Design tends to mean one thing to developers and another thing to designers. The later group are product designers and are not aware of the structure of the code.

The hipsters in the agile community are trying to blend product design into the process of coding and delivering software. This session discusses what to do after your agility is flowing, or post agilism: imagine you using agile methods successfully, what's next?

Starting with the state of state of agile methods today, we will discuss ways to incorporate discovery and design into the delivery vehicle provided by agile practices. You will find this session an excellent forum to discuss "what's next?" in a post agilist world.

By David Hussman

Many people simplistically apply agile recipes, assuming a one size fits all approach. This may lead to naive use beliefs like collocation breeds instant success. While sitting together always helps, it does not mean that people spontaneously collaborate to create sustainable value.

Instead of approaching agile methods like a recipe, this session will teach you to design agility that is a useful tool for your project community. We will cover practice selection ideas, tools for creating healthy development eco-systems and product discover tools. If you would like to improve the stickiness of your agility, stop in learn a pile of techniques to use before holding your first planning session.

Imagine you want to use agile methods and you’re looking for ideas from introduction to iteration, this is the path we will take. We start by will examining ideas for selecting which practices will improve your existing strengths and address your existing issues. From there, we will walk through growing product and customer knowledge, creating a collaborative work area and two levels of planning: planning to discover and planning to deliver.

By David Hussman

How testable are your requirements? If they are user stories, you have better odds than others, but you may still struggling to increase your automated feature testing. Acceptance test driven (ATD) means understanding the needs or the value before you start coding, and it is often hard to make ATD sticky in organizations.

While tools and geekology are needed, the upstream flow with the larger project community must exist to be successful. The session will teach you how to spark ATD from idea to code, connecting the dots and the players along the way. From product concept to automated tests, we will discuss and practice various ways to connect business, development and testing around the creating and getting value from ATD.

After a short introduction, we will practice to tasks need to take an idea to a set of testable statements. We will touch on tools, but not over focus on tools. Tools come and go and being stuck on a tool is often the failing of making ATD sticky.

The larger focus, and the deeper value, will be the importance of gathering the core players needed to create well formed acceptance tests that clarify value and promote collaboration within project communities.

By David Hussman

If you want to introduce meaningful agility in your company, real change takes more than a few certification courses or one successful pilot project. Process that produces tangible results sticks while dogmatic preaching is short lived. If you are planning to grow agility that helps you produce better products and better code in meaningful timeframes, stop in and learn how to succeed and how to avoid common failures.

The session provides answers to both why and how to coach. We will cover: 1) what successful coaches do, 2) who has the skills for the job, and 3) what is takes to move from success on one project to larger organic growth of real agility. Combining presentation, critical questioning, and small group exercise, we will practically dig into the skills needed and the challenges faced while trying to truly grow lasting agility within an organization.