New England Software Symposium

chantingrompMobile - Wireless

Dec 10, 2013 (3 years and 11 months ago)

229 views


New England Software Symposium
Sheraton Framingham
September 14 - 16, 2012
The No Fluff Just Stuff Java Symposium Series is proud to announce the return of the New England
Software Symposium on September 14 - 16, 2012. NESS2012FE will be held at the Sheraton Framingham.
Since 2001, the No Fluff Just Stuff Java Symposium has been regarded as the premier Java/Agility
event series anywhere serving over 40,000 attendees with some 250 events. The popularity of the NFJS
symposium series can be traced to the following:
1). Exceptional Speakers
2). Limited Attendance - capped at 250 people
3). No Vendors, No Sales Pitches, No Marketecture
4). Excellent networking opportunity with speakers and fellow attendees because of small size.
5). The Best Value in the Java conferencing space period.
Topics for the 2012 NFJS Tour
Languages on the JVM: Groovy, JRuby, Clojure, Scala
Enterprise Java
Core Java, Java 7
Agility
Testing: Geb, Spock, Easyb
REST
NoSQL: MongoDB, Cassandra
Hadoop
Spring 3
Automation Tools: Git, Hudson, Sonar
HTML5, Ajax, jQuery, Usability
Mobile Applications - iPhone and Android
More...
The Registration Fee Includes:
All Access Pass to NESS2012FE
All Meals/Snacks - duration of the symposium
90 Day IntelliJ license compliments of JetBrains
Session Materials
Custom NFJS Binder
Great Giveaways @ NFJS
Early Bird Registration: $875/person good thru 8/20/12 after $975
Excellent Group Discounts Available - bring your entire development team to the show - no travel
required!! Rate good thru 8/20/12
Registration Fees
Attendees
Before Aug.
20, 2012
After Aug.
20, 2012
5-9
$775
$875
10-14
$750
$850
15-24
$725
$825
25+
$700
$800
Go to http://www.nofluffjuststuff.com/conference/boston/2012/09/home and register today!

New England Software Symposium
Sheraton Framingham
September 14 - 16, 2012
Fri, Sep. 14, 2012
Ashland
Middlesex
Wayland
Carlisle
Concord
12:00 - 1:00 PM
REGISTRATION
1:00 - 1:15 PM
WELCOME
1:15 - 2:45 PM
Effective Spring
Craig Walls
AMQP: From Concept To Code
Mark Richards
Programming with HTML 5
Venkat Subramaniam
Effective Java Reloaded
Matt Stine
Introduction to Lean-Agile
Software Development
Paul Rayner
2:45 - 3:15 PM
BREAK
3:15 - 4:45 PM
Developing Next-Generation
Applications
Craig Walls
High Performance Messaging
Mark Richards
Rediscovering JavaScript
Venkat Subramaniam
Effective Java Reloaded,
Part II: Hello, Project Coin!
Matt Stine
Measure for Measure 
Lean Principles for Effective
Metrics and Motivation
Paul Rayner
4:45 - 5:00 PM
BREAK
5:00 - 6:30 PM
Building Web Applications
with Spring MVC
Craig Walls
Domain Modeling Using
Domain-Driven Design (DDD)
Paul Rayner
Automated testing tools and
techniques for JavaScript
Venkat Subramaniam
Spring-Loaded
Enterprise Integration
Matt Stine
The Art of Problem Solving
Mark Richards
6:30 - 7:15 PM
DINNER
7:15 - 8:00 PM
Keynote: Venkat Subramaniam
Sat, Sep. 15, 2012
Ashland
Middlesex
Wayland
Carlisle
Concord
8:00 - 9:00 AM
BREAKFAST
9:00 - 10:30 AM
Spring Data
Craig Walls
Strategic Design Using DDD
Paul Rayner
Know Your Enemy:
Understanding AntiPatterns
Mark Richards
Code Archaeology
Matt Stine
Integrating Groovy
and JVM Languages
Venkat Subramaniam
10:30 - 11:00 AM
BREAK
11:00 - 12:30 PM
Securing Spring
Craig Walls
Using DDD Patterns
for Supple Design
Paul Rayner
Integration Architecture:
Concepts and Patterns
Mark Richards
Functional SOLID
Matt Stine
Testing with Spock
Venkat Subramaniam
12:30 - 1:30 PM
LUNCH
1:30 - 3:00 PM
Making Java
Bearable with Guava
Daniel Hinojosa
Aggregate-Oriented
Modeling with DDD
Paul Rayner
Turtles, Architecture, & Agility
Kirk Knoernschild
Securing the Modern
Web with OAuth
Craig Walls
Executable Specifications:
Automating Your Requirements
Document with Geb and Spock
Matt Stine
3:00 - 3:15 PM
BREAK
3:15 - 4:45 PM
Developer guide to the cloud
Pratik Patel
Resource-Oriented
Architectures : REST I
Brian Sletten
OSGi Demystified
Kirk Knoernschild
Building Maintainable
Javascript with Coffeescript
David Bock
Personal Agility with the
Pomodoro Technique
Daniel Hinojosa
4:45 - 5:30 PM
BOFs
Sun, Sep. 16, 2012
Ashland
Middlesex
Wayland
Carlisle
Concord
8:00 - 9:00 AM
BREAKFAST
9:00 - 10:30 AM
Advanced JavaScript
for Java Devs
Pratik Patel
Thinking in Functional Style
Venkat Subramaniam
Modular Java
Architecture - TODAY!
Kirk Knoernschild
Resource-Oriented
Architectures : REST II
Brian Sletten
Metrics for steering your
projects to success
David Bock
10:30 - 11:00 AM
MORNING BREAK
11:00 - 12:30 PM
Put some Backbone.js or
Ember.js into your app
Pratik Patel
Scala Koans - A new and
fun way to learn a Scala
programming language
Venkat Subramaniam
and Daniel Hinojosa
Scaling Agility
Kirk Knoernschild
Resource-Oriented
Architectures : REST III
Brian Sletten
Estimating vs. Guessing
- How Agile Teams
Estimate Their Work
David Bock
12:30 - 1:15 PM
LUNCH
1:15 - 2:15 PM
EXPERT PANEL DISCUSSION
2:15 - 3:45 PM
Mobile Development Options
Pratik Patel
Programming
Concurrency with Akka
Venkat Subramaniam
Joda Time and a Brief
History of the World
Daniel Hinojosa
Maintaining Source Code Quality
(The Project Integrity Series)
David Bock
Semantic Web Workshop
Brian Sletten
3:45 - 4:00 PM
BREAK
4:00 - 5:30 PM
Mobile Performance
Tips n' Tricks
Pratik Patel
Enterprise Integration Agility
Jeremy Deane
Groovy Closures - The
way to cleaner code
Mark Johnson
Managing Complexity (The
Project Integrity Series)
David Bock
Semantic Web
Workshop (continued)
Brian Sletten

New England Software Symposium
Sheraton Framingham
September 14 - 16, 2012
Developer guide to the cloud by Pratik Patel
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.
Advanced JavaScript for Java Devs by Pratik Patel
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.
Put some Backbone.js or Ember.js into your app by Pratik Patel
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. Prerequisite: Advanced JavaScript of
JavaScript knowledge
Mobile Development Options by Pratik Patel
Mobile development is hot - and 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.
Mobile Performance Tips n' Tricks by Pratik Patel
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.
AMQP: From Concept To Code by Mark Richards
Advanced Message Queuing Protocol (AMQP) is a new way of looking at messaging that is quickly gaining
in popularity and use, particularly in the financial services industry. Unlike JMS, which defines a standard
API across platforms, AMQP defines a standard wire-level protocol across languages and platforms, finally
making true cross-platform messaging a reality. In this session I will start by describing exactly what AMQP
is and what problems it specifically solves (that JMS can't!). I will then describe the basic architecture and
how AMQP routes messages, and then, through live interactive coding, demonstrate how to build a simple
producer and consumer using RabbitMQ to send and receive AMQP messages. We will also take a brief
look at other aspects of AMQP such as performance and how to guarantee that the message reaches a
consumer. Prerequisite: basic knowledge of general messaging
High Performance Messaging by Mark Richards
If you need your messaging-based systems to be fast - really fast - then this is the session to attend. In this
session I will introduce and demonstrate some relatively simple tips and tricks to get the best performance
and throughput from your messaging system. Through live code demonstrations I will show the impact of

both configuration and design changes using ActiveMQ, HornetQ, and WebSphereMQ. So buckle up those
seat belts - its going to be a fast ride. Prerequisite: Some knowledge of JMS Messaging
The Art of Problem Solving by Mark Richards
I commonly think of those of us in the IT industry as problem solvers. Whether developer, designer,
or architect, we are all presented with problems and work to find a way to solve them, usually through
technology. In my opinion this is what makes this industry so much fun. Let's face it - we all love challenges.
Sometimes, however, the problems we have to solve are hard - really hard. So how do you go about solving
really hard problems? That's what this session is about - Heuristics, the art of problem solving. In this
session you will learn how to approach problems and also learn some the common techniques for solving
them effectively. So put on your thinking cap and get ready to solve some easy, fun, and hard problems.
Prerequisite: An open mind and a willingness to learn how to better approach and solve problems
Know Your Enemy: Understanding AntiPatterns by Mark Richards
The ancient Chinese warrior Sun Tzu taught his men to "know your enemy" before going into battle. For
us, the same thing is knowing and understanding anti-patterns - things that we repeatably do that produce
negative results. Anti-patterns are used by developers, architects, and managers every day, and are one of
the main factors that prevent progress and success. In this session we will look at some of the more common
and significant software development anti-patterns. Through coding and design examples, you will see how
these anti-patterns emerge, how to recognize when the antipattern is being used, and most importantly, how
to avoid them. Although most of the coding examples will be in Java, this is a technology-agnostic session.
Remember, like motorcycles, anti-patterns are everywhere - so be careful out there!
Integration Architecture: Concepts and Patterns by Mark Richards
Very few applications stand alone anymore. Rather, they are combined together to form holistic systems that
perform complex business functions. One of the big challenges when integrating applications is choosing the
right integration styles and usage patterns. In this session we will explore various techniques and patterns
for application integration, and look at what purpose and role open source integration hubs such as Camel
and Mule play in the overall integration architecture space (and how to properly use them!). Through actual
integration scenarios and live coding examples using Apache Camel you will learn which integration styles
and patterns to use for your system and how open source integration hubs play an part in your overall
integration strategy
Resource-Oriented Architectures : REST I by Brian Sletten
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.
Resource-Oriented Architectures : REST II by Brian Sletten
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.
Resource-Oriented Architectures : REST III by Brian Sletten
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.
Prerequisite: Resource-Oriented Architectures : REST I (or a good understanding of REST)
Semantic Web Workshop by Brian Sletten
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.
Semantic Web Workshop by Brian Sletten
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.
Effective Java Reloaded by Matt Stine
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 Reloaded, Part II: Hello, Project Coin! by Matt Stine
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.* Prerequisite: Incredibly useful to attend Part I, but not strictly required.
Spring-Loaded Enterprise Integration by Matt Stine
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.
Code Archaeology by Matt Stine
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."
Functional SOLID by Matt Stine
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.
Executable Specifications: Automating Your Requirements Document with Geb and Spock by Matt
Stine
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?
Programming with HTML 5 by Venkat Subramaniam
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.
Rediscovering JavaScript by Venkat Subramaniam
JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It's quite
popular, yet there's so much more we can do with it.
Automated testing tools and techniques for JavaScript by Venkat Subramaniam

Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability
is a design issue and with some discipline and careful design we can realize good automated tests.
Automated testing tools and techniques for JavaScript by Venkat Subramaniam
Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability
is a design issue and with some discipline and careful design we can realize good automated tests.
Integrating Groovy and JVM Languages by Venkat Subramaniam
Java - Groovy integration just works, for most part. Calling into Java code from Groovy is pretty straight
forward. Calling into Groovy from Java is easier than you may think (and that's the hard part!). There are a
few rough edges you will run into when you try to call from Groovy into other languages.
Testing with Spock by Venkat Subramaniam
Spock is an awesome tool that exploits Groovy AST transformation to provide elegant, fluent syntax for
writing automated tests.
Thinking in Functional Style by Venkat Subramaniam
Functional Programming has been around for a while, but it is gaining popularity, especially due to direct
support in languages on the JVM. Writing code in functional style is not about syntax, it is a paradigm
shift. In this presentation, using examples from Java, Groovy, and Scala, you will learn how to write code
in functional style. We will start out discussing the elements of functional programming and then look at
examples of some common operations and how you can implement those in functional style.
Scala Koans - A new and fun way to learn a Scala programming language by Venkat Subramaniam
and Daniel Hinojosa
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?
Programming Concurrency with Akka by Venkat Subramaniam
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.
Effective Spring by Craig Walls
After 9 years 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?
Developing Next-Generation Applications by Craig Walls
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.
Building Web Applications with Spring MVC 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.
Spring Data by Craig Walls
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
Securing Spring by Craig Walls
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.
Securing the Modern Web with OAuth by Craig Walls
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.
Building Maintainable Javascript with Coffeescript by David Bock
CoffeeScript is a little language that compiles into JavaScript. Underneath all of those embarrassing
braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is
an attempt to expose the good parts of JavaScript in a simple way. The golden rule of CoffeeScript is: "It's
just JavaScript". The code compiles one-to-one into the equivalent JS, and there is no interpretation at
runtime. You can use any existing JavaScript library seamlessly (and vice-versa). The compiled output is
readable and pretty-printed, passes through JavaScript Lint without warnings, and runs in every JavaScript
implementation.
Metrics for steering your projects to success by David Bock
There are a lot of things we can measure about our source code, but what about the "project as a whole" and
its overall health? Are there ways of measuring the effectiveness of our processes? Are there things we can
measure that would point to project automation wins? Is there a way to measure team 'morale'?
Estimating vs. Guessing - How Agile Teams Estimate Their Work by David Bock
Estimating is regarded as little little more than 'educating guessing', but so much can hang on the quality
of those estimates. With good estimates we can set clear expectations for project delivery, but with bad
estimates we can run over schedule and over budget, or worse. We often estimate when we know the least
about the work that needs to get done - so how can we make the best of what is potentially a bad situation?
Maintaining Source Code Quality (The Project Integrity Series) by David Bock
How many times have you started a new project only to find that several months into it, you have a big ball
of code you have to plod through to try to get anything done? Have you ever been the 'new guy' on a project
where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few
good tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we
can salvage a project that is already headed down that path.
Managing Complexity (The Project Integrity Series) by David Bock
How many times have you started a new project only to find that several months into it, you have a build
process that mysteriously fails, a bunch of 'TODO' and 'FIXME' comments in the source, and problems that
come and go because "it works on my machine"? Does your project have a little bit of 'folk wisdom' that
isn't well-known, but is necessary to get things done? How easily could you recreate your development
environment if you got a new machine today?
Enterprise Integration Agility by Jeremy Deane
Todays interconnected world requires that organizations rapidly deliver flexible-integrated solutions. The
conventional approach is to integrate heterogeneous applications using web services but unfortunately that
tends to tightly couple those applications. In this session we will explore several alternatives for achieving
Enterprise Integration Agility.
Making Java Bearable with Guava by Daniel Hinojosa

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.
Personal Agility with the Pomodoro Technique by Daniel Hinojosa
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.
Joda Time and a Brief History of the World by Daniel Hinojosa
JodaTime is Java Date/Time and Calendering done right. There are many problems with the original
Date/Time API that came prepackaged in the early Java days. There are even One of the obvious issues is
that Calendar is mutable and can unintentionally be changed. Another issue is that constructing Calendars in
Java involves setting certain fields at certain times during coding, but not always getting the expected result.
Joda Time repairs those issues and offers a robust and immutable date, time, and duration API.
Groovy Closures - The way to cleaner code by Mark Johnson
The factory patterns and callbacks have been around for a long time as a technique to provide flavor specific
code variations. But they are awkward and hard to update. Enter Groovy closures. Imagine having the ability
to inject different coding flavors using code closures. If you need a different flavor, then just pass a different
code block. Now imagine that all of this works on the JVM!
Turtles, Architecture, & Agility by Kirk Knoernschild
A little old lady once challenged a well-known scientists explanation on the structure of the universe,
countering that the world is really a flat plate supported on the back of a giant tortoise. The scientist rebutted
the little old ladys challenge with one of his own by asking what the tortoise was standing on. The little old
ladys sly reply was that its, turtles all the way down. So too is software architecture turtles all the way
down.
OSGi Demystified by Kirk Knoernschild
OSGi was once heralded as a contender for most important technology of the decade. Today, most
developers have heard of OSGi, but few are using it to develop their enterprise software applications.Is OSGi
failing? Who is using it? And what exactly are its benefits?
Modular Java Architecture - TODAY! by Kirk Knoernschild
Modularity is coming to the Java platform! Java 8 will introduce the Jigsaw module system. OSGi is here
today. Dont wait to start designing modular software. Contrary to popular belief, you don't need a framework
or a new runtime to start building modular software applications. You can start today. Learn how!
Scaling Agility by Kirk Knoernschild
We know agile methods are proven on small teams, but really...almost any process works with a team of
one. As the team scales, however, the challenges mount. In this session, we focus on proven practices that
help large software development teams in excess of 100 developers maintain agility. We also explore how to
scale agile across the enterprise.
Introduction to Lean-Agile Software Development by Paul Rayner
Successful software development is about building the right product at the right time for your customers.
This means focusing attention on the right places in the portfolio of projects and products that your company
provides, and optimizing the entire value stream from "concept to cash" for your customers and the
development teams.
Measure for Measure  Lean Principles for Effective Metrics and Motivation by Paul Rayner
This presentation explores the nature of motivation and the place of metrics and measurement in software
development, and how lean software development principles and practices shed light on motivation and
metrics and how they can be used to support deep organizational improvement.
Domain Modeling Using Domain-Driven Design (DDD) by Paul Rayner

This presentation seeks to provide a solid introduction to the fundamentals of DDD. Learn why modeling a
complex business domain in software is so advantageous to your business and ways in which your team can
go about delivering software models to give your business a competitive edge.
Strategic Design Using DDD by Paul Rayner
Not every part of a software system will be well-designed. How do you know where to put the time and effort
to refine the design, or refactor existing code? Learn how strategic Domain-Driven Design (DDD) patterns
can show you how to know which parts of your system matter most to your business and how to focus your
team's design efforts most effectively. Prerequisite: Domain Modeling using Domain-Driven Design (DDD)
Using DDD Patterns for Supple Design by Paul Rayner
Come on a guided tour of how applying Domain-Driven Design (DDD) building block patterns can make your
code cleaner, more expressive, and more amenable to change. We cover examples of DDD patterns such
as entities, value objects, closure of operations and side-effect-free functions. We will focus particularly on
how implementing value objects can lead to more supple design. Prerequisite: Domain Modeling using
Domain-Driven Design (DDD)
Aggregate-Oriented Modeling with DDD by Paul Rayner
Many of the problems encountered in scaling, parallelizing and distributing systems that tend to be
addressed in ad-hoc ways are actually deeply connected with the manner in which the business domain has
been modeled. Domain-Driven Design has rich modeling resources for tackling concurrency, transactional
and distribution boundary issues within the domain model itself, enabling teams to be more effective in
dealing with business complexity and change. Prerequisite: Domain Modeling using Domain-Driven
Design (DDD)