Derek Lane

Presentations

Maven 2: Your New Favorite Power Tool

Ant was created because Make was too clumsy and wasn’t Java-aware. Ant has introduced a generation of developers to a new set of build practices. But Ant has grown far beyond the original intent of its inventor. It has turned into a bloated, general purpose scripting tool which can require a significant amount of time to maintain and customize. Is there a better way? The answer is a resounding, You Betcha!

Maven can reduce the time you take to maintain your builds, handle a load of dependency checking for your code base, help manage production deployments, versioning of artifacts, and automatically generate a slew of reports. What are you waiting for? Join us to explore Maven and how it can help your project.

SpringUnit: The Latest Way to Maximize Your Spring Testing!

Having trouble writing data-driven tests using Spring? Would you like a little more power writing integration tests for you Spring Beans? This session explores the latest tool you can put in your little bag of Spring tricks: SpringUnit!

One of the great things about dependency injection is that it helps you develop your application in a more testable way. Writing your tests first enhances this value even more. However if you write enough tests, you eventually find that some types of tests are more difficult to write, even with the added decoupling that dependency injection provides.

Ted Velkoff discovered this and decided to do something about it. He loved Spring but wanted to write tests that were more data-driven than were possible out of the box with Spring. So he decided to write a surprisingly simple little framework that you can use to ease data-driven and integration testing with Spring.

This session will introduce the original intent of SpringUnit, illustrate how it works, and provide some objective observations to help you determine if it can help you on your project.

When is an Estimate Just an Estimate?

All software projects have to provide estimates. Webster defines estimate as, "to determine roughly the size, extent, or nature of". Whens the last time you provided an estimate that wasn't taken as a guarantee?

The movement toward Agile software development has been to put estimates back in their place, as rough sizing techniques. Estimating should be quick, yet based on something concrete so that it has meaning. This session will introduce some simple techniques for estimating things on your software projects (requirements, tasks, etc.), and provide hints on variations that have been applied on real world projects. These techniques are aimed at lowering the bar to adopting and integrating true estimation into your current project.

Topics covered in this practical, hands on session are:

• What are the cultural problems around estimating?
• What factors can influence the ability and accuracy of estimates?
• What key factors can improve project estimates over time?
• What are some techniques that you can start using next week to improve estimates?

Creating DSLs with ANTLR

We've all heard the buzz around creating internal Domain Specific Languages (DSLs) in languages such as Ruby and Groovy, and indeed this excitement is well founded. The ability to develop software which communicates in ways familiar to people in the domain is very powerful. But there is a natural limit to the expressiveness of any given programing language, and there are situations when an internal DSL is not sufficient.

In these situations parser generators such as ANTLR (ANother Tool for Language Recognition) really shine. In this presentation you will see how a DSL can be built from the ground up with ANTLR. You will gain an overall understanding of how the major components of ANTLR collaborate to translate structured text into valuable inputs for your applications. And many insights will be shared along the way highlighting best practices and common pitfalls to avoid.

Build the Right System

The software profession faces many challenges including our general approach to requirements. A high percentage of implemented functionality is seldom used and requirement deficiencies are frequented cited among the top five reasons for project failure.

How can we as software professionals and craftsmen know that we are producing the most valuable system at just the right time for our users? The concept of "pull" from lean manufacturing, in combination with agile values and practices, provides a powerful guide for how we can improve our profession by allowing the incremental specification of functionality to "pull" the creation of working software. In this workshop participants will experience how a real working system can be constructed from the ground up through the definition of executable specifications. In a cycle comparable to that of Test Driven Development participants will see how, through a series of micro-iterations, requirements can pull the creation of executable specifications, integration tests, unit tests, and production code. Along the way we will also touch on related subjects such as code coverage, mocking, and user-interface testing.

What's the Deal with Functional Languages?

In the last year or so, there has been a growing buzz in the development community around functional languages. Some of these languages, such as LISP, have been around for decades while others are relatively new, like Scala. But collectively, they have been garnering a lot of attention. This session aims to cut through the buzz and give you an understanding of why there has been a resurgence of interest in the these languages.

Topics covered include:

1. What makes a language a functional language?
2. Features and differentiators of several functional languages including Erlang, Haskell, LISP, Scala, and Schema.
3. Where do these languages fit in the overall development landscape?
4. What concepts of functional languages can be applied to for mainstream OO languages, such as Java?