By Tim Berglund

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

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

This is a mile-wide, ankle deep view of an open-source business intelligence stack. Through this whirlwind overview, you'll learn the basic principles of business intelligence, how to think architecturally about the components of a BI stack and how to integrate them into the enterprise, and what specific tools you can employ to get the job done.

By Tim Berglund

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

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

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

By 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

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

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

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

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

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

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

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

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

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

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

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

By Ted Neward

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we begin by looking at the Scala type system and flow-control primitives, such as if/else, pattern-matching, tuples, lists, and more. Despite the name, "basics" in Scala can get the newcomer Scala developer quite some distance.

By Ted Neward

Watch Preview Video

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

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

By Ted Neward

Watch Preview Video

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

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

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

By 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 message on a queue, write to the database (again using JPA). A JTA transaction allows you to ensure that the entire set of operations is committed or a rollback is performed. In this presentation, the developer will understand the limitations and configuration of using JTA and JPA together ? primarily through real code examples.

Once unit tests are written, developers often gloss over doing fine-grained integration testing just for their persistence layer. Integration testing with JPA means simply one thing: running your JPA components against your target database, for example, Oracle. Overlooking this aspect leads to problems being discovered later in the test cycle (UAT for example) and makes it more difficult to find and fix bugs. This presentation will use live code examples to explain a strategy for getting integration testing for free by reusing unit tests.

Using optimistic locking versus pessimistic locking seems clear cut to most developers. However, a full understanding of the issues with using pessimistic, or datastore, locking is required before making this decision. Developers will get information in the trade offs when using strategy or the other, and how these strategies can be used together with the same persistence unit.

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

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 learn some of the tips and tricks to performance tune.

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

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

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

By Nathaniel Schutta

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

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

By Nathaniel Schutta

Watch Preview Video

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

By Ken Sipe

You are using Java, whew!!! No need to worry about memory, the garbage collector will handle that. Those who have had a memory issue in Java are not so naive any more. Often memory utilization and heap sizes are an after thought and are not recognized until the application is in production, often caused by application uptime, production request volume or production sets of data. When the OutOfMemory Error occurs, often the science of development seems to brake down and knobs are turned. First the (-mx) maximum heap space gets adjusted... More is better right. The next OutOfMemory, heads start scratching, code reviews start in earnest, and Google gets several new hits. Did you know that it is possible to get an OutOfMemory error without running out of heap space?

This talk will walk through the underlying details of memory management in the JVM with a focus on VM flags available to help configure the VM. However we can't configure the VM without a detailed understanding of what is going on inside the VM. We'll focus on tools available for analyzing the memory in a running VM. Two actual client case examples will be presented. We'll discuss the differences between the two cases and why the end configurations were quite different.

By Ken Sipe

So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.

Combined with proper JMX instrumentation, the need to bounce the server may be eliminated for all but the rarest of cases.

This session will look at the Java 6 monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. In addition to what is provide in the JDK, a number of freely available management tools will be demonstrated.

By Ken Sipe

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

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

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

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

By Ken Sipe

Security is a large concern in today's world of software development. Security is a multi-dimensional problem requiring skills at a number of different levels. This session is a security overview of a typical Java web development stack.

This session initiates a discussion in the following overlapping areas of security: - Java security - JEE security, which includes JAAS - Spring Security - Operating System security and it's roll in web security - Web Application security - Securing the wire with SSL - Key Management with keystore

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 is an emerging Data Web that relies 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 the practical and accessible aspects of employing these ideas 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

Prerequisite: The Semantic Web: The Future, Now and Rich Web Pages : Publishing Semantic Content with GRDDL and RDFa would both be helpful but are not required

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

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

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

Watch Preview Video

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

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

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

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

By Craig Walls

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

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

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

By Craig Walls

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

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

This talk unveils the missing link in enterprise Java development: simple, portable integration tests. For many, working in enterprise Java has long been an arduous undertaking because of this void. While development life is simple with unit tests and mocks, they only take you so far. Eventually, you need to validate how your components interact and operate in their intended environment--you real need integration tests. Yet, writing integration tests has meant assuming the burden of bootstrapping all or part of your infrastructure. That's time lost and it places a mental barrier on testing. Arquillian and ShrinkWrap, two new projects from the JBoss Community, partner to tear down this barrier and reduce Java enterprise testing to child's play. Come experience how.

Arquillian, a container-oriented testing framework layered atop TestNG and JUnit, brings your test to the runtime rather than requiring you to manage the runtime from your test. Picking up where unit tests leave off, Arquillian enables you to test real components that rely on real enterprise services in a real runtime.

We'll look at how the fluent API provided by ShrinkWrap is used to package a test archive, giving developers fine-grained control over which resources are available to be tested. We'll show examples of how the test archive is deployed and executed inside standalone, embedded and remote containers. You'll witness how RPC-style (or local, if applicable) communication between the test runner and the environment negotiates which tests are executed and reports back the results. You'll walk away confident that

1. you can write integration tests just as you would a unit test and
2. the test is portable to multiple environments (containers).

What’s the secret? This talk reveals how Arquillian simplifies integration testing by providing a component model for tests, just as Java EE 5 simplified server-side programming by providing declarative services for application components. The test component model consists of container lifecycle management, test enrichment (dependency injection), container deployment and in-container test execution. Using a component model means your tests are portable and able to move between different environments, from single embedded or remote to multi-server to multi-cloud nodes.

Attend this talk to learn about the future of Java enterprise testing.

By Dan Allen

This talk introduces JSR-299: Contexts and Dependency Injection for the Java EE platform (CDI), the new Java standard for dependency injection and contextual lifecycle management. The talk covers the core programming model, explains its relationship to EJB 3.1 and JSF 2.0, and clarifies how it unifies and enhances the Java EE platform as a whole (extending to JPA, JAX-RS and JMS). You are then introduced to Weld, the JSR-299 reference implementation, and its servlet container extension. Finally, we look ahead at how a modularized Seam 3 ties into this new foundation as a set of portable CDI extensions, previewing several examples.

JSR-299: Contexts and Dependency Injection for the Java EE platform (CDI) is an elegant set of new services for Java that draws upon ideas from popular frameworks such as Seam and Guice and hooks into all the major specifications in the platform, including JavaServer Faces (JSF) 2.0, Enterprise Java Beans (EJB) 3.1, the Java Persistence API (JPA) 2.0 and JAX-RS 1.1. While many of the features provided by CDI--dependency injection, contextual lifecycle, configuration, interception, event notification--are familiar, the innovative use of meta-annotations is uniquely expressive and typesafe. This talk emphasizes the value in this approach.

Seam is a powerful open source development platform for building rich Internet applications in Java. Seam 3 is built on CDI and integrates technologies such as Java Persistence (JPA 2.0), Business Process Management (jBPM), Wicket, PDF and Excel reporting, Security and email into a unified full-stack solution, complete with sophisticated tooling.

In this discussion, Dan will talk about upcoming developments in Java EE 6 including CDI 1.0 and JSF 2.0 and how they set the foundation for Seam 3. This is a great opportunity to learn about how Red Hat is building on this new revision of the Java EE platform.

By Aaron Bedra

Ruby has made an significant upward trend in the past few years. Alongside this trend Charles Nutter and the fantastic JRuby team have implemented a version of Ruby that runs on the JVM giving you the power of Ruby coupled with the advantages of running on the JVM. Come see for yourself how you can harness the power of rapid development in Ruby and still maintain all the Java interoperability you need to help you build on top of your existing systems.

In this Session you will take a look at some real world examples of how JRuby can help you:

• Write new software that wraps existing Java libraries
• Utilize JMX to monitor your production code
• Increase the effectiveness of your test suites

This session will leave you with new information that can help you decide if JRuby is right for your next application or feature.

By Aaron Bedra

Find out why Clojure is Java.next

• Clojure provides clean, fast access to all Java libraries
• Clojure provides all the low-ceremony goodness you know and love from dynamic languages
• Clojure includes Lisp's signature feature: Treating code as data through macros.
• Clojure's emphasis on immutability and support for software transactional memory make it a viable option for taking advantage of massively parallel hardware.

Clojure is a dynamic programming language for the Java Virtual Machine, with a compelling combination of features:

• Clojure is elegant. Clojure's clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.
• Clojure is Lisp reloaded. Clojure has the power inherent in Lisp, but not constrained by the history of Lisp.
• Clojure is a functional language. Data structures are immutable, and most functions are side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.
• Clojure simplifies concurrent programming. Of course, Java itself has pretty good concurrency support, but there is wide agreement that lock-based concurrency is difficult to use correctly. Clojure provides alternatives to lock-based concurrency: software transactional memory, agents, and dynamic variables.
• Clojure embraces Java. Calling from Clojure to Java is direct, and goes through no translation layer.
• Unlike many popular dynamic languages, Clojure is fast. Wherever you need it, you can get the exact same performance that you could get from hand-written Java code.

By Aaron Bedra

Exploring new technologies can be both challenging and rewarding. A good spike can make or break a new feature for your application. Have you ever thought that a technology or practice your company isn't currently using is the perfect fit for your next iteration? This is your time to shine! In this session you will learn how to treat new technologies as first class citizens and prove that they fit your needs. You will also learn how to provide concrete evidence supporting your decision. By the end of this session your fear of introducing new technology will simply melt away.

In this session you will learn how to cover the cross cutting concerns of bringing new technology into your organization. You will walk through ideas including:

• Initial proof of concept
• Fully functional demonstration
• Stress testing
• Operations
• Presenting your findings
• Bringing your team up to speed

You will also learn about arming yourself with these concepts to help make your case. There's no better time than now to start learning how to leverage the right tool for the job.