Continuous Delivery Pt 1: Deployment Pipelines

Neal Ford

Friday 1:15 PM - Salon C

Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. This workshop focuses on the Deployment Pipeline concept from Continuous Delivery.

In this workshop I move from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. I spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.

Groovy, part 1: Collections, closures, and the Groovy JDK

Kenneth Kousen

Friday 1:15 PM - Raleigh

Want to use Groovy but don't have time to read all of Groovy in Action? This talk gives you a whirlwind introduction to its capabilities, from basic data types, Groovy strings, POGOs, collections, Groovy SQL, and the Groovy JDK.

Learn the basics of Groovy through code examples, including both scripts and classes. A complete set of test cases is included, as well as a gradle build script to download everything you need and run all the tests.

Effective Spring

Craig Walls

Friday 1:15 PM - Salon A/B

After almost a decade and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?

In this session, we'll explore several ways that Spring has changed over the years and look at the best approaches when working with the latest versions of Spring.

MongoDB: Scaling Web Applications

Ken Sipe

Friday 1:15 PM - Durham

Google ?MongoDB is Web Scale? and prepare to laugh your tail off. With such satire, it easy to pass off MongoDB as a passing joke? but that would be a mistake. The humor is in the fact there seems to be no end to those who parrot the MongoDB benefits without a clue. This session is about getting a clue.

Get past the hype and hyperbole associated with NoSQL. This session will introduce MongoDB through live working sessions demonstrating the pros and cons of MongoDB development. The session will then focus on a recent short project focused on large scale. We?ll discuss database design to support high scale read access. Throughout this case study we will discuss the consequences of the MongoDB choice. The session will finish with a review of the production topology to support growth in scale.

Advanced JavaScript for Java Devs

Pratik Patel

Friday 1:15 PM - Salon D

So you think you've picked up enough JavaScript to be dangerous, but feel like the whole prototypical language thing is still a mystery. In this session, we'll go from basic JavaScript to advanced JavaScript. We'll discuss and code modular JavaScript with CommonJS. We'll look into the details of a prototype language and discuss things like parasitic inheritance. We'll also look at JavaScript libraries that will help you get the most out of JavaScript - not jQuery, but a library like UnderscoreJS and SugarJS.

This is a fast paced session meant to bring you up to speed with the latest and greatest JavaScript techniques and tools. Whether you're building client side JavaScript with HTML5 or Appcelerator Titanium, or server-side JavaScript with node.js, you'll come away with knowledge and patterns for how the pro's use JavaScript for building real apps.

Groovy, part 2: Builders, metaprogramming, and AST Transformations

Kenneth Kousen

Friday 3:15 PM - Raleigh

Want to use Groovy but don't have time to read all of Groovy in Action? Building on the Groovy 101 talk, this presentation reviews features of Groovy that aren't based on simplifying Java. Topics include building and parsing XML and JSON, using the metaclass to enhance existing classes, and Abstract Syntax Tree Transformations like @Delegate, @Immutable, @Canonical, and more.

Learn the basics of Groovy through code examples, including both scripts and classes. A complete set of test cases is included, as well as a gradle build script to download everything you need and run all the tests.

Developer guide to the cloud

Pratik Patel

Friday 3:15 PM - Salon D

There's a ton of options for deploying to the cloud right now. Heroku and Engineyard are among the well known Platform as a Service (PaaS) providers. What if you don't want to use these PaaS services? What if you don't know which one is better? Are they cost effective? What about private deployments into internal infrastructure? This session answers these questions with a discussion of PaaS services and setting up your own PaaS using CloudFoundry.

There's a ton of options for deploying to the cloud right now. Heroku and Engineyard are among the well known Platform as a Service (PaaS) providers. What if you don't want to use these PaaS services? What if you don't know which one is better? Are they cost effective? What about private deployments into internal infrastructure? This session answers these questions with a discussion of PaaS services and setting up your own PaaS using CloudFoundry.

Continuous Delivery Pt 2: Infrastructure

Neal Ford

Friday 3:15 PM - Salon C

Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. This workshop focuses on the agile infrastructure required to implement a deployment pipeline and continuous delivery.

In this workshop, I introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.

Developing Next-Generation Applications

Craig Walls

Friday 3:15 PM - Salon A/B

For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.

But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.

With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.

In this session, we'll discuss what the next generation of applications looks like, exploring such things as the mobile web and cloud computing. We'll also dig into some of the technologies and practices such as REST, OAuth, and JavaScript microframeworks that enable us to move forward.

Enterprise Security API library from OWASP

Ken Sipe

Friday 3:15 PM - Durham

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.

Functional Thinking

Neal Ford

Friday 5:00 PM - Salon C

Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard.

This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional langauges as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you'll leave with a much better understanding of both the syntax and semantics of functional languages.

Getting Agile Right!

Ken Sipe

Friday 5:00 PM - Durham

Whether you are just getting started, or you?ve made an attempt and well? it could be better? a lot better, this session is for you. Ken has been working on Agile projects as a coach and mentor for a number of years. Come discover the common reasons teams fail to get it right. Bring your own challenges and lets discuss. This is set to be an engaging and illuminating discussion.

This can be a dynamic discussion where challenges facing attendees may have us to focus on some areas and tips of agile development. We will certainly talk about how team or management choices to deviate from core agile practices add risk to a project with suggestions on how to resolve many of these challenges.

Mobile Development Options 2013

Pratik Patel

Friday 5:00 PM - Salon D

There's a bevy of options for developing mobile apps. If you're looking at cross-platform solutions, there's a multitude of options to choose from. In this session we'll explore the three basic categories for developing mobile apps: native, cross-platform-to-native, and mobile web. We'll discuss the sweet spot for each of these three approaches and the benefits and drawbacks of each. Technologies discussed include Android, iOS, HTML5/CSS3, Phonegap, Titanium, and jQuery Mobile.

There's a bevy of options for developing mobile apps. If you're looking at cross-platform solutions, there's a multitude of options to choose from. In this session we'll explore the three basic categories for developing mobile apps: native, cross-platform-to-native, and mobile web. We'll discuss the sweet spot for each of these three approaches and the benefits and drawbacks of each. Technologies discussed include Android, iOS, HTML5/CSS3, Phonegap, Titanium, and jQuery Mobile.

Gradle Fundamentals

Kenneth Kousen

Friday 5:00 PM - Raleigh

The Gradle build tool is one of the most successful projects in the Groovy ecosystem because it addresses a difficult problem -- every major build is a custom build. Gradle builds are written in Groovy, so the full power of the language is available if you need it. Gradle supports Maven project structure and repositories and uses Ivy dependency management without being bound by their normal constraints. With major systems like Grails, Hibernate, and the Spring Framework moving to Gradle, this is a technology worth taking the time to understand.

This talk will cover the basics of Gradle both through simple examples and by examining the build files for major open source projects.

Spring Data

Craig Walls

Friday 5:00 PM - Salon A/B

This session starts with a high-level look at all that the Spring Data project has to offer. Then we'll dive deeper into a few select Spring Data modules, including Spring Data Neo4j, Spring Data MongoDB, Spring Data Redis, Spring Data JPA, and Spring Data JDBC Extensions

In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.

With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.

Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new "NoSQL" databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.

The Elusive Truth and False Dichotomies in a Broken Reality

Ken Sipe

Friday 7:15 PM

"To say of what is that it is not, or of what is not that it is, is false, while to say of what is that it is, and of what is not that it is not, is true" -- Aristotle

This talk is a fun look at what is true, or what we think is true... how we know what we know or think we know and what it depends on. Through the evening we will learn about every day dichotomies that can lead to black and white thinking. We will use a dichotomous key to learn such things as; is a tomato a vegetable or a fruit? Is a carrot a vegetable or a fruit? As we reveal the truth, we will see how the perceived norms of the world are broken and in what way they are broken. With this new found knowledge we will discuss how to detect it and correct it. These are the foundational skills of the master craftsman... and that's the truth!

Build Your Own Technology Radar

Neal Ford

Saturday 9:00 AM - Salon C

A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company.

ThoughtWorks' Technical Advisory Board creates a "technolgy radar" 3 or 4 times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This session describes the process we use and how to adapt it to both your company and, more importantly, yourself. For career risk mitigation, you must know what the next big thing is, or at least be able to narrow it to a reasonable list. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organization) develop a cogent strategy to make good choices.

Building Web Applications with Spring MVC

Craig Walls

Saturday 9:00 AM - Salon A/B

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.

Spock - Unit Test and Prosper

Ken Sipe

Saturday 9:00 AM - Durham

Spock is a groovy based testing framework that leverages all the "best practices" of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans... and you get Spock!

This is a significant advancement in the world of testing.

This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool.

Effective Java Reloaded

Matt Stine

Saturday 9:00 AM - Salon D

Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in "Java the language" in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.

In his foreward to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.

Effective Java is organized into 78 standalone "items," all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers. You'll pick from a menu and decide where we'll head. Regardless of the path we take, you'll leave this session thoroughly equipped to write better Java code tomorrow!

Mobile Performance Tips n' Tricks

Pratik Patel

Saturday 9:00 AM - Raleigh

Creating a web site, web app, or native app for mobile use presents a special set of challenges. Specifically, developers and designers should be zoned into the techniques for usability - and usability can be enhanced greatly by taking performance elements into consideration up-front. In this session, we explore the many performance tips and tricks you can employ to make your website or web app or native app shine on mobile devices. This is an advanced course that discusses issues such as image loading, JavaScript performance, and wireless latency.

Creating a web site, web app, or native app for mobile use presents a special set of challenges. Specifically, developers and designers should be zoned into the techniques for usability - and usability can be enhanced greatly by taking performance elements into consideration up-front. In this session, we explore the many performance tips and tricks you can employ to make your website or web app or native app shine on mobile devices. This is an advanced course that discusses issues such as image loading, JavaScript performance, and wireless latency.

Effective Java Reloaded, Part II: Hello, Project Coin!

Matt Stine

Saturday 11:00 AM - Salon D

Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in "Java the language" in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.

Effective Java is organized into 78 standalone "items," all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers.

*In Part II of this session, we'll cover those items we were unable to reach during Part I. We'll follow that up with a dive into the new features available in Java 7, describing new idioms for effective Java programming in the following areas:

• Strings in switch statements
• Enhanced syntax for numeric literals
• Improved exception handling
• ARM (automatic resource management) blocks
• Type inference for construction of parameterized types (the "diamond" operator)

Put some Backbone.js or Ember.js into your app

Pratik Patel

Saturday 11:00 AM - Raleigh

We've come a long way down the JavaScript road. Gone are the days of 'just hack it' for the web - architecting even a small project in JavaScript can be a challenge. Thankfully, there are several frameworks to help you; the most popular currently is Backbone.js. In this session, we'll assume you know nothing of Backbone.js, and we'll build a small application using Backbone.js as the foundation. We'll also build the same app using Ember.js, another popular JavaScript framework.

Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface. Ember.js is another popular framework that provides client-side code structure. It takes a different approach than Backbone.js, but provides more features. Ember.js came out of the SproutCore project and emphasizes bindings.

Complexity of Complexity

Ken Sipe

Saturday 11:00 AM - Salon C

Of all the non-functional requirements of software development, complexity receives the least attention and seems to be the most important from a long term standard point. This talk will look at some of forces that drive complexity at the code level and at a system level and their impact. We will discuss what causes us to over look complexity, how our perception of it changes over time and what we can do about it?

In this session we will break down the meaning of complexity and simplicity and measure the application of those means against the common software development dogma. Looking at common development trends and pressures, we'll discuss where simplify does and doesn't help. We will examine areas of development which at first glance seem to be simple (such as the creation of an equals method in Java), that end up being difficult or impossible based on normal constraints. We will example the drivers of complexity with some discussion on what you can do about it. This session will finish with a discussion around several challenges to high scale software architectures and how to keep it simple.

4 Practical Uses for Domain Specific Languages

Neal Ford

Saturday 11:00 AM - Durham

Domain Specific Langauges seems like a cool idea, but where's the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job.

This talk defines of DSLs (Domain Specific Languages), distinguishes the types of DSLS (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you're already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you've never seen anything about it, but keeps the focus on practical goals.

Securing Spring

Craig Walls

Saturday 11:00 AM - Salon A/B

In this session, I'll show you how to secure your Spring application with Spring Security 3.0. You'll see hot to declare both request-oriented and method-oriented security constraints. And you'll see how SpEL can make simple work of expressing complex security rules.

Although we may invite guests into our homes and give someone a ride in our car, we locks and alarms on our homes and our cars to keep uninvited and malicious visitors out. Similarly, we allow people to use the applications that we develop, but we probably want to control the access that they have.

Security is an important aspect of any application. And while we could program security rules into the web controllers and methods in our application, we'd find ourselves cluttering our business logic with repetitive security code. Security is a cross-cutting concern--begging to be handled with aspect-oriented techniques.

Spring Security is an authentication and access-control framework based on Spring that provides security aspects. With Spring Security, you can declare who is allowed to access your application and what they're allowed to see, keeping your application logic focused and uncluttered with security details.

Securing the Modern Web with OAuth

Craig Walls

Saturday 1:30 PM - Raleigh

In this session, we'll look at OAuth, focusing on OAuth 2, from the perspective of an application that consumes an OAuth-secured API as well as see how to use OAuth to secure your own APIs.

Web security is nothing new. As users of the web, we're all accustomed to entering our usernames and fumbling to recall our passwords when trying to access private data on one of the many online services we use. But while traditionally web security could be described as a two-party process between a web application and a user, the modern web involves applications that seek to access other applications on behalf of their users. This presents some new challenges in keeping a user's sensitive data secure while still allowing a the third party application to access it.

OAuth is an open standard for authorization, supported by many online services, that allows one application to access a user's data in another application, all while giving the user control of what information is shared.

Web Security Workshop

Ken Sipe

Saturday 1:30 PM - Durham

As a web application developer, most of the focus is on the user stories and producing business value for your company or clients. Increasingly however the world wide web is more like the wild wild web which is an increasingly hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.

This training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The first session will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks. It will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.

The workshop will include several hands on labs from the webgoat project in order to better understand the threats that are ever so common today.

Attendees will come away with the following skills / capabilities: - threat modeling - security audit plan - introduction to Pen testing - key / certificate management - fixing web application security issues

Don't be the weakest link on the web!

Functional SOLID

Matt Stine

Saturday 1:30 PM - Salon D

Robert Martin assembled the SOLID family of principles to provide a useful guide to help us create object-oriented software designs that were resilient in the face of change. In recent years, the need to write highly-concurrent software in order to leverage increasingly ubiquitous multicore architectures, as well as general interest in more effectively controlling complexity in large software designs, has driven a renewed interest in the functional programming paradigm. Given the apparent similarity in their goals, "What is the intersection of SOLID with functional programming?" is a natural question to ask.

In this talk, we'll explore this intersection. We'll begin with a brief overview of Martin's catalog of software design smells, which describe properties of software designs that have not addressed change effectively, and thereby become increasingly hard to evolve. We'll then take a tour through the SOLID principles, addressing the following topics:

• What is the principle?
• What design smells does it combat?
• How does it work?
• Does it still apply within the functional paradigm?
• How can multiparadigmatic (combining concepts from OO, functional and other paradigms) programming better align with the principle?
• Examples from Java
• Where a particular language feature greatly enhances alignment with the principle, examples from Groovy, Scala and Clojure

Introduction to Virtual Machines and Interpreters

Douglas Hawkins

Saturday 1:30 PM - Salon C

Have you ever wondered what goes on inside the virtual machines and interpreters that we use every day?

In this session, you'll see some of the inner workings of Python, PHP, Java, and JavaScript and learn that at the lowest level these languages really are not as different as they may seem.

An overview of the basic parts of a virtual machine and interpreter that compares and contrasts the different approaches taken by different modern languages.

Leading Technical Change

Nathaniel Schutta

Saturday 1:30 PM - Salon A/B

Technology changes, it's a fact of life. And while many developers are attracted to the challenge of change, many organizations do a particularly poor job of adapting. We've all worked on projects with, ahem, less than new technologies even though newer approaches would better serve the business. But how do we convince those holding the purse strings to pony up the cash when things are "working" today? At a personal, how do we keep up with the change in our industry?

This talk will explore ways to stay sharp as a software professional. We'll talk about how a technology radar can help you stay marketable (and enjoying your career) and how we can use the same technique to help our companies keep abreast of important changes in the technology landscape. Of course it isn't enough to just be aware, we have to drive change - but how? This talk will consider ways we can influence others and lead change in our organizations.

Web Security Workshop

Ken Sipe

Saturday 3:15 PM - Durham

As a web application developer, most of the focus is on the user stories and producing business value for your company or clients. Increasingly however the world wide web is more like the wild wild web which is an increasingly hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.

This training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The first session will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks. It will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.

The workshop will include several hands on labs from the webgoat project in order to better understand the threats that are ever so common today.

Attendees will come away with the following skills / capabilities: - threat modeling - security audit plan - introduction to Pen testing - key / certificate management - fixing web application security issues

Don't be the weakest link on the web!

Hacking Your Brain for Fun and Profit

Nathaniel Schutta

Saturday 3:15 PM - Salon C

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.

Spring-Loaded Enterprise Integration

Matt Stine

Saturday 3:15 PM - Salon D

The book Enterprise Integration Patterns gave us a consistent vocabulary and notation with which to describe solutions to common integration problems that arise in the modern enterprise. Spring Integration (http://www.springsource.org/spring-integration) harnesses that vocabulary, providing a very natural extension to the well-known Spring programming model that enables the construction of loosely-coupled, messaging-based applications that can also integrate with services in the wild via a variety declarative adapters for heavily used protocols. This talk will provide an overview of the Spring Integration framework, it's relationship to the patterns, and to the problems they aim to solve. We'll also look at several integrated case studies.

Topics covered will include:

• Framework background, goals and principles
• Messages, Channels and Endpoints
• Transformers
• Filters
• Routers
• Splitters and Aggregators
• Service Activators
• Channel Adapters (Feeds, Files, FTP/FTPS, HTTP, Mail, TCP/UDP, JDBC, JMS, RMI, SFTP, Twitter, ...)
• Integrated Case Studies

Resource-Oriented Architectures : REST I

Brian Sletten

Saturday 3:15 PM - Salon A/B

The first in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

The REpresentational State Transfer (REST) architectural style has emerged as a winning strategy for building scalable, flexible, resilient systems that lead with an information focus. Far from being the simple "Web Services through URLs" idea many people have about them, REST-based systems require a new perspective, a fair amount of consideration and the discipline to look beyond simple point-to-point interactions.

The benefits are exciting and provide a gateway to a whole new world of information technology. This first talk will be an introductory session covering the basics of the REST architectural style.

Virtual Machines and Interpreters II: Inside the Java Virtual Machine

Douglas Hawkins

Saturday 3:15 PM - Raleigh

In part II of VMs and Interpreters, you'll dive into the inner workings of the Java Virtual Machines. You'll learn how your Java code is translated from Java source code to byte code and ultimately machine code.

You'll also see tools for viewing Java byte code and measuring performance changes caused by VM optimizations.

This session will cover the... - Java class file format - Java byte code - How Java 5 and Java 7 features are implemented to maintain compatibility - JVM Optimizations

Scala Koans - A new and fun way to learn a Scala programming language (Bring a Laptop)

Venkat Subramaniam and Daniel Hinojosa

Sunday 9:00 AM - Raleigh

Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.

If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?

Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.

JavaScript Libraries You Aren't Using...Yet

Nathaniel Schutta

Sunday 9:00 AM - Salon C

You're all over jQuery - you write plugins in your sleep - and before that, you were a Prototype ninja. Your team treats JavaScript like a first class citizen, you've even written more tests than Kent Beck. Is that all there is in the land of the JavaScript developer? Believe it or not, the JavaScript party hasn't stopped. What other libraries are out there? What do they offer? This talk will survey the field of modern JavaScript libraries getting you up to speed on what's new. We'll dive in just deep enough to whet your appetite on a wide variety of libraries such as Backbone, Underscore, Zepto and more.

You're all over jQuery - you write plugins in your sleep - and before that, you were a Prototype ninja. Your team treats JavaScript like a first class citizen, you've even written more tests than Kent Beck. Is that all there is in the land of the JavaScript developer? Believe it or not, the JavaScript party hasn't stopped. What other libraries are out there? What do they offer? This talk will survey the field of modern JavaScript libraries getting you up to speed on what's new. We'll dive in just deep enough to whet your appetite on a wide variety of libraries such as Backbone, Underscore, Zepto and more.

Understanding Garbage Collection

Douglas Hawkins

Sunday 9:00 AM - Durham

Most of us don't want to go back to the days of malloc and free, but the garbage collector isn't always our friend.

In this presentation, you'll learn about the different garbage collection strategies used in JVMs, how to monitor garbage collection, analyze memory dumps, and why you might want to use one collection strategy instead of another.

Practical Lean for the Practicing Developer

Matt Stine

Sunday 9:00 AM - Salon D

Much is said today by the software methodology "talking heads" about the need for organizations to "go lean." The question is, what does it mean to go lean? Is this the job of IT management? Or is it the job of the practicing software developer? And furthermore, does this simply mean the adoption of of another set of processes and procedures? Or is it something entirely different?

Ultimately, going lean simply means removing all of the impediments that prevent our organizations from achieving more of "the goal." While that goal may differ from context to context, for the vast majority of us that means "making more money," by improving our efficiency at moving from, as the Poppendieck's have so aptly said, from "concept to cash."

While a great many of us do not have the role power necessary to spur top-down organizational change, there are many practical things each of us can do to bring the power of "going lean" to our teams. As we apply these principles and practices to our day-to-day work, we can build the credibility necessary to become change agents.

In their books, the Poppendieck's have helpfully summarized lean software development into seven principles:

1. Eliminating Waste
2. Building Quality In
3. Creating Knowledge
4. Deferring Commitment
5. Delivering Fast
6. Respecting People
7. Optimizing the Whole

In this talk we'll walk through each of these principles and examine how we as individual contributors and software teams can make practical, actionable changes within our own spheres of influence that will ultimately help us to deliver more value to our organizations.

Resource-Oriented Architectures : REST II

Brian Sletten

Sunday 9:00 AM - Salon A/B

The second in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

People already familiar with REST (or who have attended the first session) will be walked through the deeper topics of building Level 3 Hypermedia-based RESTful systems, security, content negotiation, etc.

Resource-Oriented Architectures : REST III

Brian Sletten

Sunday 11:00 AM - Salon A/B

The third in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

The move to a good REST API yields an explosive combination of options due to content-negotiation and arbitrary workflows. At the same time, the uniform interface you project (representations, how you respond to verbs, response codes, etc.) becomes your contract with your clients. The API itself becomes a completely transportable, reusable bit of organizational knowledge when done well. Testing it sufficiently will give you a safety net but may drive you crazy unless you do it right. We will walk through the use of Behavior-Driven Development (BDD) to test these kinds of APIs.

We will highlight the problems of sufficiently testing REST APIs while providing a rich and relatively straight-forward solution to the problem. We will use a Behavior-Driven Development (BDD) tool like Cucumber to establish reusable steps and comprehensive, but lightweight testing strategies for testing REST APIs.

This talk will not be an introduction to REST. If you have come to the REST I or REST II talk, or have a good understanding, it should be very accessible.

Inside Android's Dalvik VM

Douglas Hawkins

Sunday 11:00 AM - Durham

Android is gaining popularity rapidly, but why does Android use its own implementation of Java?

In this presentation, we'll dig into the details behind Android's Dalvik VM. Along the way, you'll learn about Android' s service architecture, Dalvik's byte code format, and the surprising details of how Android installs, launches, and executes your applications.

Code Archaeology

Matt Stine

Sunday 11:00 AM - Salon D

Feature requests are steadily pouring in, but the team cannot respond to them. They are paralyzed. The codebase on which the company has "bet the business" is simply too hard to change. It's your job to clean up the mess and get things rolling again. Where do you begin? Your first task is to get the lay of the land by applying a family of techniques we'll call "Code Archaeology."

In this session we will learn how to systematically explore a codebase. We'll look at what tools are available to help us out, slinging some wicked shell-fu along the way. We'll look at "code islands" and "code bridges," and how to construct a "map of the code." We'll also examine the wisdom that thought leaders like Michael Feathers and Dave Thomas have leant to this subject.

Once we've gained a thorough understanding of what we have in front of us, we'll learn approaches for getting the system under test and refactoring so that we can start to pick up the pace and respond to user requirements without making a bigger mess. You'll leave this session well prepared to tackle the next "big ball of mud" that gets dumped on your desk.

Programming with HTML 5

Venkat Subramaniam

Sunday 11:00 AM - Salon C

Developing a rich user interface for web applications is both exciting and challenging. HTML 5 has closed the gaps and once again brought new vibe into programming the web tier. Come to this session to learn how you can make use of HTML 5 to create stellar applications.

.

The Who and What of Agile - Personas and Story Maps

Nathaniel Schutta

Sunday 11:00 AM - Raleigh

Successful projects require any number of practices but if you don't know who you're building it for or what you're supposed to build, failure is a distinct possibility. How do we capture the who and what? Personas and story maps are two effective techniques that you can leverage. After discussing the basics, we'll break into small groups and you'll have a chance to actually try building a set of personas as well as a story map.

Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months and months of effort.

Of course just knowing who we're building for is only part of the picture, we have to know what our users are trying to do. Wether you favor use cases, user stories or more traditional requirements documents, at the end of the day our customers are using our application to further some other goal.

Programming Concurrency with Akka

Venkat Subramaniam

Sunday 2:15 PM - Raleigh

I call the JDK concurrency API as the synchronize and suffer model. Fortunately, you don't have to endure that today. You have some nice options, brought to prominence on the JVM by Scala and Clojure.

In this workshop, learn how to program with Actors and STM using Akka, a powerful and popular library created using Scala but usable from any language on the JVM. You have a choice to pick the language you like in this workshop, and learn how to use these powerful concurrency models.

Executable Specifications: Automating Your Requirements Document with Geb and Spock

Matt Stine

Sunday 2:15 PM - Salon C

One of the hallmarks of lean software development is the elimination of waste. Several of the key wastes in software development revolve around incomplete, incorrect, or obsolete documentation, especially documentation of requirements. One effective means of ensuring that your requirements documentation is complete, correct, and up-to-date is to make it executable. That sounds nice, but how do we get it done, especially in the world of modern, cross-browser web applications?

Executable web application specifications are within your reach through the combination of Spock, a testing and specification framework written for the JVM in Groovy, and Geb, an elegant Groovy wrapper around the powerful WebDriver browser automation framework. In this session we'll take a close look at Spock specifications for describing and verifying the behavior of our applications. We'll then examine how we can use Geb's implementation of the Page Object pattern and its "jQuery-ish" API for interacting with our web applications in WebDriver's range of supported browsers. Finally, by gluing these two technologies together via Geb's Spock integration, we'll automate the requirements specification for a simple web app.

Designing for Mobile

Nathaniel Schutta

Sunday 2:15 PM - Salon A/B

The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app...it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This talk will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.

The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app...it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This talk will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.

Semantic Web Workshop

Brian Sletten

Sunday 2:15 PM - Durham

The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

In this workshop, we will:

Explain the Web and Web architecture at a deeper level Apply Web and Semantic Web technologies in the Enterprise and make them work together Integrate structured and unstructured information Create good, long-lived logical names (URIs) for information and services Use the Resource Description Framework (RDF) to integrate documents, services and databases Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)

Bring your laptops. This is a hands-on workshop.

Making Java Bearable with Guava (2013 Edition)

Daniel Hinojosa

Sunday 2:15 PM - Salon D

This presentation covers the Guava library developed by Google (http://code.google.com/p/guava-libraries/). Guava provides collection extensions to the Java Collection API and, along with this, a cornucopia of time-saving utilities that bring Java as close as possible to some of the more functional and dynamic language competitors like Scala, Ruby, and Clojure.

This presentation focuses on the following topics: how to make Predicates and Functions; how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets; how to set up and use Guava preconditions; and how to create truly immutable collections, and more. All of this is done with Java. All code is stored on github. Laptops are optional but bring them over if you want to play along.

Semantic Web Workshop

Brian Sletten

Sunday 4:00 PM - Durham

The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

In this workshop, we will:

Explain the Web and Web architecture at a deeper level Apply Web and Semantic Web technologies in the Enterprise and make them work together Integrate structured and unstructured information Create good, long-lived logical names (URIs) for information and services Use the Resource Description Framework (RDF) to integrate documents, services and databases Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)

Bring your laptops. This is a hands-on workshop.

Applying Groovy Closures for fun and productivity

Venkat Subramaniam

Sunday 4:00 PM - Raleigh

You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.

In this presentation, we will unlock that treasure and explore ways in which we can design applications using Groovy closures, to apply different design patterns, to create fluent interfaces, and even program asynchrony.

Master of Puppet

Matt Stine

Sunday 4:00 PM - Salon D

Puppet is a powerful framework for the automation of tasks typically performed by system administrators as part of software infrastructure provisioning and maintenance. Puppet adoption is rapidly increasing, boasting use by companies such as Google, RedHat, Constant Contact, Zynga, and Shopzilla.

Puppet is composed of three principle components:

• a declarative language for expressing system configuration,
• a client and server for distributing it,
• and a library for realizing the configuration

We'll dive deeply into Puppet's architecture and features, including its idempotent configurations, cross-platform resource abstraction layer, and graph-based modeling of resources, resource providers, and resource relationships. We'll then leverage puppet to set up infrastructure of a typical JVM-based web development project with various OS, application server and datastore configurations. You'll leave a "Master of Puppet," ready to apply it on your next software delivery effort.

Personal Agility with the Pomodoro Technique

Daniel Hinojosa

Sunday 4:00 PM - Salon C

Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.

In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.

The Mobile App Smackdown: Native Apps vs. The Mobile Web

Nathaniel Schutta

Sunday 4:00 PM - Salon A/B

Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.

Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.