By Neal Ford

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

By Neal Ford

Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!

In The Productive Programmer, I identify 4 principles of productivity: acceleration, focus, automation, and canonicality. This session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. Canonicality (the DRY principle from The Pragm

By Neal Ford

BRING YOUR LAPTOP WITH YOU, BUT A LAPTOP ISN'T REQUIRED! Reading and hearing about agile practices is one thing, but actually doing it is completely different. This session puts you to work in an agile fashion, applying agile developer practices.

Reading and hearing about agile practices is one thing, but actually doing it is completely different. This session puts you to work in an agile fashion, applying agile developer practices. During this session, we're going to take a problem and iteratively develop the solution, using test-driven development, pair programming, retrospectives, pair rotation, and other agile development techniques. We should be able to get through about 3 20-minute iterations during the 90 minutes, giving you a hands-on feel for real agile development. If you have a laptop, bring it, but only half the class needs one, so if you don't have a laptop, don't let it discourage you. Come see what it's like to work on

By Neal Ford

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. 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.

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. 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 t

By Neal Ford

Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.

This session shows one of the reasons that JRuby is the most

powerful mainstream language today: meta-programming. It shows tons of

meta-programming techniques in Ruby, including open classes, the shadow

meta-class, defining methods, method_ & const_missing, dynamically

adding and removing mixins, and more. And each of these comes with an

example that actually makes sense!

Session TopicsModulesStructsFreezingMessages and Dynamic InvocationThe Shadow Meta-classCode as ObjectsDelegationOpen ClassesAspectsMissing! Const Method ReflectionMixology

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

By Neal Ford

What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.

Agile projects focus on delivering code. The responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools (both byte and source code), useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks.

Session Topics:The Hawthorne EffectHow Agility and Metrics Feed Eac

By Neal Ford

This talk covers language techniques in Java, Groovy, and Ruby on how and why to create DSLs, and also covers the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

Domain specific languages have been the Next Big Thing for years now, but they have quietly started penetrating the development world. This talk covers language techniques in Java, Groovy, and Ruby on how and why to create DSLs. This session demonstrates with motivation for converting APIs into DSLs, and various patterns, anti-patterns, and best practices for how to achieve the optimum effect. This talk also covers the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

By Ted Neward

  Even though the Java 7 JSR has yet to be formed, some interesting things are beginning to emerge from Sun about what Java7 may include when its formal release contents are finally made public.

In this presentation, we'll examine some of the forthcoming details, including some of the JSR-166 "add-ons" like the Fork/Join framework, some of the proposals for extensions to the JVM to support dynamic languages, and the so-called "closures" proposals circulating around.

By Ted Neward

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

By Ted Neward

So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place.

In this presentation, we'll pick up where the "Platform Security" talk leaves off, and demonstrate how to engage the security model of the JVM at a much deeper level, regardless of your favorite programming language: Java, JRuby, Groovy, Scala, ....

Prerequisite: The Busy Java Developer's Guide to Platform Security

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

With the release of the OpenJDK source code, Java developers have been given a unique opportunity to peer inside the hood of the JVM, see what's there, and how Java code actually executes.

In this presentation, we'll talk about how to get the OpenJDK codebase, how to compile it (for both Windows and Linux systems), and point out some of the more interesting aspects of the JDK source base. Developers will walk away with a deeper appreciation for exactly what happens when they run Java code. Innocents beware--we're a long way from "Hello, Java" with this one.

By Ted Neward

Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play.

In this presentation, we'll examine several of the "hackable" customization points inside the JVM: the boot classpath, allowing us to add or modify existing JDK classes without violating the license agreement; the JNI Invocation API, allowing us to create custom Java launchers to establish an environment for the JVM that corresponds to exactly the way we want it; or even replace core Java classes with our own versions. Innocents beware--we're a long way from "Hello, Java". (Attendees should have some familiarity with C/C++ code and native build practices to get the most out of this talk.)

By Mark Richards

One way to stop a conversation dead while at a party or gathering is to mention you are a software architect. Why? Because it takes about an hour (complete with Powerpoint slides) to explain what you do for a living. By then the person you are talking to is so bored they would rather sit in a corner licking nine-volt batteries. The problem is that no one inside or outside our industry really knows what a software architect is or what they do. In this highly interactive (and slightly humorous) session we will take a deep dive into the role a software architect plays in the IT industry. We will explore the characteristics an architect needs to have, and the elements that make a good architect and a bad architect. Through amusing antidotes and real-world examples, we will see how to become an effective software architect and help shape the industry in terms of the role and title of software architect.

Agenda

During the introduction we will talk about the roles an architect plays, architect certification, and the decisions an architect typically makes. We will then take a deep dive into the qualities of a software architect, including Leadership and Communications, Technical Knowledge and Breadth, Domain Knowledge, and Methodologies. Interspersed into the mix will be some amusing anecdotes of my experiences as an architect, with a few jokes and humor thrown in for good measure

Prerequisite: None

By Mark Richards

In the book "97 Things Every Software Architect Should Know" (O'Reilly, 2009) I wrote about the importance of design patterns as a useful means of communication between architects and developers. Equally important to patterns is an understanding of AntiPatterns - things that we repeatably do that produce negative results. AntiPatterns 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 development and architecture antipatterns. Through coding and design examples, you will see how these antipatterns emerge, how to recognize when the antipattern is being used, and most importantly, how to avoid them. By attending this session, you will be part of a movement to reduce the AntiPattern catalog from hundreds of entries to only a few.

Agenda

- What are anti-patterns?

- Factors that cause anti-patterns

- Common software and architecture anti-patterns

I have selected 7 of the most common anti-patterns I see continually in the industry and in my travels. We will be going into the details of each of these anti-patterns.

Prerequisite: None

By Mark Richards

In previous years I have given sessions related to my book "Java Transaction Design Strategies", where I have reviewed the basics of programmatic and declarative transactions and outlined the basic patterns described in the book. In this new session for 2009 I will focus on some of the pitfalls encountered while dealing with transactions and then how to develop an effective transaction strategy. I will start this session by describing and illustrating some of the common pitfalls I continue to see in both Spring and EJB. I will then describe four common transaction strategies you can use and implement, including a transaction strategy for high-speed transactions, a transaction strategy for client orchestration, a transaction strategy for use with API's, and finally a strategy for highly concurrent environments.

Note: This session assumes you know a little bit about transactions and have been using them in either Spring or EJB. It is not intended to be an introductory session on how transactions work. You can obtain a free PDF download of my transaction book at http://www.infoq.com/minibooks/JTDS to quickly come up to speed with transactions.

Agenda

- Introduction

- Common Transaction Pitfalls

- API Transaction Strategy

- Client Orchestration Transaction Strategy

- High Concurrency Transaction Strategy

- High Speed Transaction Strategy

Prerequisite: Java, Spring or EJB; some knowledge of transactions and JTA.

By Mark Richards

There's no doubt about it - messaging is quickly becoming a standard part of most application architectures, particularly as more and more companies struggle to find ways to integrate heterogeneous environments due to mergers, acquisitions, or to streamline existing application portfolios. The Java Message Service (JMS) API allows Java applications to implement messaging using a standard API, therefore removing the dependency of any particular messaging provider. In this introductory session we will take a look at the basics of messaging and the JMS API. I will start by discussing the different messaging models, the structure of a basic JMS message, and the JMS API interfaces and how they interrelate. Then through interactive coding I will show the basics of sending and receiving messages using the point-to-point messaging model and how to do request/reply processing. NOTE: this session is meant to be an introduction to messaging and JMS - no prior JMS or messaging experience is needed for this session.

Agenda:

- Messaging Introduction

- JMS Message Types

- Primary JMS Interfaces

- Configuring Queues and Topics

- Sending and Receiving Messages

- Request/Reply Messaging

Prerequisite: None

By Mark Richards

This session covers some of the more advanced features of JMS messaging, and is intended for those who are familiar with JMS and messaging in general. Some of the topics I will be covering in this session include message grouping (where I will demonstrate sending a large JPG image using messaging), transacted sessions, client-based acknowledgement, and some various messaging design considerations and things to watch out for from a design and coding perspective. I will be doing live coding demonstrations to illustrate the techniques described in this session. Although this session is entirely JMS provider agnostic, I will be using ActiveMQ, a popular open source JMS provider, during the live coding demonstrations.

Agenda

- Details behind the acknowledgement modes

- Message grouping / sending images and documents

- Transacted sessions

- JMS Design Considerations

- Common Messaging Pitfalls

Prerequisite: Some knowledge of messaging and JMS would be helpful

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

The Spring Framework has led the industry in innovation for years. Starting with dependency injection and promoting testing through removal of framework dependencies. Spring 3.0 continues that innovation in a way that takes full advantage of the Java 5 platform. There are a number of significant changes to the framework. So whither you are new to the framework or an experience Spring developer, this is a great session to come up to speed on the latest from SpringSource.

This will cover all the new features in Spring 3 complete with demos. This will include a look at the following:

- Spring MVC

- Spring REST

- Spring EL

- Spring Portlet

- Spring Declarative Validation

Prerequisite: Java 5

By Ken Sipe

Thoughts lead to words, words lead to action, actions lead to habits. In this session we'll sharpen the development saw in the process of understanding what makes a hyper-productive programmer. The focus will consist of developer habits and development processes.

As described in the book "7 Habits for Highly Effective People", there are habits which are characteristic of highly effective people. Clearly there are hyper-productive developers which distinguish themselves from the development pack? what is it that makes the difference? What are the habits and practices of highly effective developers?

This session will focus on individual developer habits, as well as team practices and the processes which result in high quality running software.

By Ken Sipe

Scale... what is scale... how do you applications that are scalable. How do you know if the application scales?

This session will look at server topologies and state management and how it affects scale. We'll detail a number of metrics to know and observe. In addition tools of the trade will be demonstrated such as jmeter.

By Brian Sletten

There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.

If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old

By Brian Sletten

If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.

The Restlet API was created by a guy who wanted object-level support for RESTful concepts, but didn't want to make the move to an advanced resource-oriented environment like NetKernel. He wanted his REST and conventional environments too. He also wanted a path to more modern containers that aren't tied to a blocking I/O model like the Servlet spec is.

This talk will include a brief review of REST and its primary concepts and will then provide an introduction to the Restlet API and how it supports these ideas. It will then focus on standing up a REST-oriented infrastructure using the Restlet API and a variety of other open source tools to support a publish/find/bind infrastructure without to

Prerequisite: REST (unless you are very comfortable with REST)

By Brian Sletten

Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.

NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.

Come see how this open source / commercial product can change the way you think about building software.

NetKernel makes the things you are doing now easier, but also makes new types of systems possible.

A wise man once said, "XML is like lye. It is very useful, but humans shouldn't touch it." If you've had to incorporate XML into your project by hand, you have probably been burned by getting too close. NetKernel turns this wisdom on its head and encourages you to use XML like the liquid data stream you want it to be.

But, XML is only part of the story. Resource-oriented computing is a generalized and revolutionary approach to modern, flexible systems. There is less code to write, but it is more fun to do. Orchestration of existing services and data sources is faster, easier and more encompas

By Brian Sletten

If you have come to the NetKernel overview talk and came away compelled but unsure how to proceed, this talk will jump right in to building real resource-oriented systems with NetKernel. We will move away from the theoretical mind-melting right into the applied mind-melting. It is difficult to make the shift away from an object-oriented model, but this talk will demonstrate several examples of how and why you may want to. It will also include a preview of what is coming in NetKernel 4. This is kind of a REST + Polyglot Programming + SOA + Architecture talk all rolled up into one.

This talk will build out:

Wrappers around a relational database that can act as RESTful interfaces through HTTP or service higher layers

Transformational layers that convert the data into different forms

Orchestration across a variety of data sources

Integration with a variety of web tier technologies

All along the way, we will make appropriate language choices to solve our problems. One size does not fit all and an environment that embraces this is incredibly important.

Prerequisite: Intro to NetKernel : Software for the 21st Century, Give it a REST (if unfamiliar with REST)

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

Communication is a key piece of organizational success. We are constantly trying to find new ways to improve how we share ideas, concepts, issues and needs. E-mail has lost its luster. Phone calls are too disruptive. We want a combination of presence-aware and asynchronous. Instant messaging has started to fill this void but using public services are often inappropriate for sensitive conversations.

This talk will focus on two open source offerings: the OpenFire XMPP (Jabber) server and the Smack client library. Come hear how you can adopt these technologies in your daily activities more fully.

OpenFire is an Enterprise-class open source XMPP Server offering a variety of features, a rich plugin infrastructure, user management, etc.

The Smack API is a client-side library with support for chat, presence awareness, file-transfers, multi-user chatrooms, etc.

We will set up the server and walk through increasingly rich interaction including the development of a smart agent that will attach to your conversations, log them, identify important references, etc.

By Venkat Subramaniam

How is testing done on agile projects? Do we need testers when programmers can write tests? When do we do test? If the requirements are evolving, should we postpone testing until they stabilize?

This presentation will address how you can approach testing in agile projects. We will discuss the role of programmers and testers in testing, the tools and techniques they can use. We will discuss when testing can start and how it can proceed. This session is intended for both programmers and testers who are actively involved in agile projects.

By Venkat Subramaniam

Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you.

In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.

By Venkat Subramaniam

Groovy brings the dynamic productivity to the Java platform. One of the strengths of Groovy is the seamless integration with Java–it preserves the Java semantics. However, Groovy does have some differences that can surprise you if you're not expecting.

In this Jeopardy style presentation, you will pick topics you'd like to discuss and we will understand the strengths and differences Groovy brings in those areas.

By Venkat Subramaniam

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.

In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

By Venkat Subramaniam

Projects often start out simple, but soon become complex and turn into a lose cannon. Organizations are struggling to maintain and evolve software. Poor code quality is a significant part of that problem. Improving the quality of code is critical to success of enterprise projects.

In this presentation we will discuss ways to identify code smell. We will discuss several

code smells and how to clean it up. We will also discuss proactive ways to avoid that smell

in the first place.

By Stuart Halloway

Git is not the next step in evolution of centralized source control, following in the footsteps of cvs, svn, etc. These tools provide centralized history of deltas, where git provides distributed history of trees of content. In this talk, you will see the advantages of the git approach:

Incredible speed. Local, disconnected operation. Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with git. Cheap and easy branching, tagging, and merging. Editing and refactoring your commits.

You have probably heard about git by now, perhaps something along these lines: "Git is a version control system, and it is more powerful that Subversion in every way. You don't even have to be online to commit!"

This is true, but it undersells git. Git is not the next step in evolution of centralized source control, following in the footsteps of cvs, svn, etc. These tools provide centralized history of deltas, where git provides distributed history of trees of content. In this talk, you will see the advantages of the git approach:

Incredible speed.

Local, disconnected operation.

Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with gi

By Stuart Halloway

The Agile Manifesto, like any good scripture, admits of many interpretations. There is no one "right path." What works for us may not work for you. At Relevance we have tried many paths, and learned many lessons. Join us to see dozens of ideas that have worked for us, plus some that haven't.

The Agile Manifesto states four key values:

Individuals and interactions over processes and tools.

Working software over comprehensive documentation.

Customer collaboration over contract negotiation.

Responding to change over following a plan.

That manifesto sounds great, but perhaps a little vague. It gets more concrete quickly when you start doing it! In this talk, we will share our experiences, both good and bad, with various practices and problems associated with agile:

Pairing all the time (except when we don’t)

Running cross-project retrospectives

Code coverage standards

Choosing the sharpest tools

Fixed-bid projects

Handling budget problems

Teaching customers

By Stuart Halloway

Teams adopting agile should begin at a tactical level, but they shouldn't end there. The Agile Manifesto operates at many different levels. Learn to apply the principles of agile at a strategic level. Otherwise you can have a great agile ground game and still lose.

Many programming teams now embrace agile at the tactical level, which is the right place to begin. Applying the ideas in the Agile Manifesto, good teams embrace practices like

story point estimation

burndown tracking

technical expertise

behavior-driven development

daily standups

pair programming

continuous integration

spiking

refactoring

customer always available

well-understood roles

The Agile Manifesto can be applied at a strategic level, too. However, the tensions are different. Feedback cycles are longer, objectives and results are less clear, and roles and relationships are unknown or changing. In this talk you will learn how

By Stuart Halloway

In this talk, we will explore and compare four of the most interesting JVM languages: Clojure, Groovy, JRuby, and Scala. Each of these languages aims to greatly simplify writing code for the JVM, and all of them succeed in this mission. However, these languages have very different design goals. We will explore these differences, and help you decide when and where these languages might fit into your development toolkit. For more information see http://blog.thinkrelevance.com/2008/9/24/java-next-overview.

As we reach the middle of our second decade of Java experience, the community has learned a lot about software development. Many of our best ideas on how to use a Java Virtual Machine (JVM) are now being baked into more advanced languages for the JVM. These languages tend to provide two significant advantages:

They reduce the amount of ceremony in your code, allowing you to focus on the essence of the problem you are solving

They enable some degree of functional programming style. Think of it as a dash of verb-oriented programming to spice up your noun-oriented programming.

In this talk, we will explore and compare three of the most interesting new JVM languages: Clojure, Groovy, JRuby, an

By Stuart Halloway

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 such as Ruby and Python.
• 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 is 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 simpli?es concurrent programming. Of course, Java itself has pretty good concurrency support. Bu

By Mark Johnson

You have probably heard about Grails, a Rails based development framework which claims to make software development a breeze. You have heard the hype and are now wondering about the reality, will it really work in your environment? Has it really lived up to the hype? This presentation reviews the results using Grails to develop the New England Java Users Group event management web site to answer these questions.

Some of the topics which we can discuss during this session include; creating the initial application, security, plugins, performance, memory usage, and testing.

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!

This session will use hands on examples to explore how to use and create closures. In addition, during the discussion we will also discuss when it is appropriate and inappropriate to use closures in your applications.

By Mark Johnson

The problem with testing is you need to make certain that the test is validating a "true" business requirement. Most business folks can't read code, so they have to trust that we are testing the right stuff. The reports generated as part of the webtest process are actually human readable, so you can validate with the business stakeholders that your tests properly cover "true" requirements. Throw in Groovy and closures into the mix with WebTest and you have the ability to implement many high powered, clearly understandable tests taking full advantage of re-usable code allowing for many different tests with the same code block.

This session will include hands on examples to illustrate various techniques of writing Canoo Webtests using the Groovy language.

By Mark Johnson

As developers we dread when management requests a project estimate. Typically, you do not have the opportunity to understand all the requirements, the team composition is unknown, and you have been given until tomorrow end of day to produce an estimate. Several months later everyone is yelling at you about the software estimation errors encountered during the project.

This presentation will cover some simple techniques for creating order of magnitude estimates. In addition, leveraging the cone of uncertainty the presentation will also cover techniques for managing management expectations.

By Mark Johnson

When we start a project, our management hands us a copy of MS Project and using this tool we are expected to accurately track the project to completion. What often ends up happening is many of the project tasks are listed as 90% complete and you don't have a clear understanding of the blocking reasons. This presentation will explore various vendor independent time efficient dashboard options you can pursue to properly track your project.

Specifically, we will work through an software project example using various types of burn down and velocity charts, Staffing activity, change control management, and defect management.

By Srini Penchikala

Even though many companies have some kind of application architecture standards, they don't usually have a mechanism to enforce those standards. As a result of this lack of architecture governance, the Implementation (Code) often doesn't match the Requirements (Reference Architecture). Enforcing Reference Architecture guidelines promotes consistency and modularity in the System. It also helps in detecting structural complexity and preventing it earlier in the software development process. As a result, the application code is modifiable, portable, and testable.

In this presentation, I will talk about the significance of enforcing the architecture rules and standards and how to actually enforce them in software development projects. I will start off the discussion explaining various types of architecture rules that range from simple module dependencies to enforcing how APIs and specific idioms should be used. All these rules usually fall into categories such as Layered Architecture, Separation Of Concerns, Domain Driven Design, and Infrastructure. Some of the rules examples will include basic validations like DAO (Persistence) layer shouldn't depend on any other layers, Presentation layer should not use DAO classes directly, and Service layer should never call web layer. Separation of concerns rules are no transaction management in DAO classes and Service layer should be transactional. More sophisticated rules like that are used in a Domain Driven Design project such as Service object creation through a Factory object (i.e. no Service instantiation using the new keyword), No direct access to DAO's except from the Domain classes (go through Domain or Repository objects), and Business service that fails with a concurrency related failure can be retried.

The presentation will also include the discussion on Static and Dynamic Analysis architecture enforcement setup types and the techniques and tools architects can use for the enforcing the rules. Some of these techniques include Aspect-Oriented Programming (AOP), AspectJ Design Level Assertions (DLA's) and Design by Contract (DbC). As for the tools, Macker can be used for identifying module (package) dependency violations and other tools like Contract4J, SonarJ and Lattix can be used for more comprehensive rules enforcement. The session will include a demo of enforcing architecture rules in a sample Java application using Aspects as well as SonarJ tool. The attendees will be able to take awa

Prerequisite: This is an advanced AOP talk. It assumes the attendees are familiar with AOP and Aspects design concepts.

By Srini Penchikala

In this technical session, I will discuss Domain Driven Design and Development from a practical implementation stand-point. The presentation looks at various architectural and design factors, best practices, frameworks and tools that affect the design of a business domain implementation project. It also covers the impact of various design concerns like Dependency Injection (DI), Aspect Oriented Programming (AOP), Persistence, Caching, Transaction Management and Application Security in Domain Modeling and Domain Driven Design problem space. The session also provides the domain model and code examples based on a real world DDD implementation project that utilized agile software development techniques such as SCRUM, Test Driven Development and Refactoring to realize a great success in completing the project on time and under budget.

Domain Driven Design (DDD) is about mapping business domain concepts into software artifacts. Most of the writings on Domain Driven Design (DDD) topic to-date have been based on Eric Evan's "Domain Driven Design" book, covering domain modeling and design aspects mainly from a conceptual and design stand-point. These writings discuss the main elements of DDD such as Entity, Value Object, Service etc or they talk about concepts like Bounded Context and Anti-Corruption Layer. While these concepts are important in a real-world DDD implementation, the practical side of DDD hasn't gotten enough attention from domain modeling community.

In this technical session, I will discuss Domain Driven Desig

By Srini Penchikala

Java Application Architecture is going through a major paradigm shift in terms of design techniques, technologies, and frameworks that are used to build and deploy Java applications. Enterprise JavaBeans (EJB), traditional Message Queues (JMS), and even Application Servers as we know them are being replaced by light-weight POJO based frameworks such as Spring, ActiveMQ, and OSGi compatible containers.

This technical session will give an overview of Java application architectures of the past where EJB's, verbose EAR files and heavy-weight J2EE application servers were the only choice a Java developer had to develop and implement Java applications to the current pragmatic architectures where the concepts like POJO's and Domain Driven Design (DDD) have become the core design and development concerns like they should be. The presentation will also include a discussion on how concerns like Persistence, Transaction Management, Application Security and Asynchronous Messaging have become the infrastructure concerns that are managed by the frameworks (like Spring) out-of-the-box instead of developers having to spend a lot of time and effort in programming or dealing with complex configuration files and deployment descriptors for implementing these concerns.

The presentation will talk about the emerging design techniques like Domain Driven Design, Domain Specific Languages (DSL), Custom Annotations, Dependency Injection (DI), Aspect-Oriented Programming (AOP) and OSGi. I will also discuss the use cases where these techniques add value to the architecture and where they may be just an overkill.

The presentation will include the demo of a sample Java application that uses the techniques discussed in the session. I will also demonstrate how these techniques can be used in different phases of SDLC phases of the application (Architecture, Design, Development, Unit Testing and Implementation) as well as post implementation efforts such as Clustering and Monitoring.

By Jared Richardson

Has your career been a random product of your manager's whims or company's needs? Never rely on your company to keep your skills current and marketable. Take control of your own career with a proven strategy.

These are solid, repeatable steps to get your career in the trajectory you want. The first step is deciding where you want to go. We'll walk through creating a long-term plan, then break it down into manageable steps. Learn to lead within your own company, then stretch out to your local, regional and national community, building your reputation as you go. From coding to writing to speaking, each step will move you closer to where you want to be: in a position of having options and in control of your career.

By Jared Richardson

Technical debt has long been recognized in technical circles for years, but convincing your manager to budget time to repay "technical debt" has always been problematic. Let's couch the term technical debt concept in language more familiar to our managers: credit card debt.

Like credit card debt, technical debt accumulates slowly over time, and usually takes just as long to pay off. The interest slowly builds up until you're no longer able to pay off the principle: your entire development cycle is devoted to just "paying the interest". We'll examine common types of technical debt and strategies to effectively communicating the problems, and their solutions, to your managers.

By Jared Richardson

There are a number of great techniques you can use across technologies and projects. Come hear some of my favorite ways to move "beyond" and contribute a few of your own. We'll discuss topics ranging from glue languages to ditching your IDE to building your brain.

In this session we'll discuss:

- Move beyond tools

- Glue languages

- Inbox Zero

- Learning to learn

- Not being a cog anymore

- Macro Object Orientation

- Clean code

- Looking smarter than you are

- Open source tool stacks

- Tighter feedback loops

- Scripted deployments

- Scripting databases

- Virutalization

And more...

By Jared Richardson

Agile is wildly popular in some circles and hated in others. How can the same ideas cause such different reactions? Sometimes it's the definition of "agile" and other times it's company culture, but there's usually a good reason when Agile ideas are thrown out on their collective ears.

In this talk we'll discuss what works about Agile, how advocates have tainted the word in many companies, and how you can move great ideas forward successfully on your team.

By Srivaths Sankaran

Creating great code gets harder every day. But using the right tool, and embracing tried & tested habits can greatly improve your productivity. This session will focus on such tools and other quality enhancing techniques. You will also learn specific habits that will help you shine and elevate you above the masses.

.

By Srivaths Sankaran

The Eclipse IDE has matured over several years to become quite a powerful tool with a robust plugin-based architecture. It gives commercial IDEs such as IDEA a run for their money. Yet, most developers barely scratch the surface of its capabilities. This talk will expose you to features that will greatly enhance your productivity. You will learn tips and tricks that will make you more efficient in your development activities and allow you to focus on solving the business problem at hand. Along the way you will be introduced to improvements introduced by the recent Galileo release.

.

By Srivaths Sankaran

Unsuccessful projects dominate the landscape of IT projects by a wide margin. Retrospectives are common occurrences and the advent of newer project delivery techniques hasn't proven to be the miracle cure. Some projects have lemon written all over them at the time of arrival and others just wither away for want of proper care and feeding.

This talk introduces you to a variety of project problems and how to address them. You will learn techniques that will get you off on the right foot and habits that will ensure smooth progress throughout the project's lifecycle. The net result will be a project that hits its target and a customer that is happy.

.

By Srivaths Sankaran

Wouldn't it be nice if you didn't have to worry about mundane project administrivia? What if all your build, deployment, configuration and documentation problems just disappeared?

We will see how you can do just that with Maven. This session will introduce you to Maven. It will teach you how to use it to set up your project & effortlessly manage dependencies. You will learn how easy it is to tailor it for your specific needs. Using Maven, developing professional documentation including reports from several popular quality and metrics gathering tools is a snap. By the end of this session, you will be a true Maven maven.

.