Clojure is getting a lot of positive buzz, but what is it like building and shipping a real application? In this talk, we will cover the good, the bad, and the ugly of commercial Clojure development, including:

• BDD meets FP: how we adapted spec and test practices for functional code
• To wrap or not to wrap: working with Java libraries
• The learning curve: training a team of non-Clojurists on Clojure
• What you will wish for: third-party libraries you should know about, plus some that don't exist yet
• Good names or die: living without object context
• Shipping it: how to manage staging and deployment of Clojure code

Experience with Clojure is useful but not a prerequisite; we will introduce the key concepts as we go.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Clojure in the Field" for your organization, or view our curriculum if you are interested in a complete course.

jQuery is a powerful JavaScript library for dealing with HTML, events, animations, and Ajax. Unlike many libraries, jQuery puts the browser object model front-and-center through its ubiquitous wrapped element sets. In this talk, you will learn to progressively enhance your web applications the jQuery way: with unobtrusive, functional JavaScript.

Along the way, you will learn how to:

• select and modify elements with jQuery's powerful selectors
• use jQuery's utility functions
• register event handlers, including dynamic ones that track changes to the page over time
• play nice with other libraries with noConflict
• create Ajax requests that return HTML, JSON, and other data types
• breathe life into your interface with effects and animations
• unit test your JavaScript code with Screw.Unit, Smoke, and blue-ridge

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Introduction to jQuery" for your organization, or view our curriculum if you are interested in a complete course.

Agile teams manage change and risk by apapting. But to adapt, you must identify opportunities for change and take them. Retrospectives are a fun, cost-effective way for your team to learn and change.

In this talk, we will begin by conducting a mini-retrospective, so that you get a feel for the basic process. Next, we will review the core principles of a retrospective, and use these principles to compare and contrast a variety of retrospective activities from the book Agile Retrospectives.

Next, we will explore a few retrospective activities in greater detail. These are some of the favorites that we use regularly at Relevance:

• team radar
• prioritize with dots
• learning matrix

Finally, we will talk about how to tune retrospectives to the needs of your team at a specific moment in time. No two retrospectives are alike, and an experienced facilitator adds value by adapting a retrospective to meet the current need.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Agile Retrospectives" for your organization, or view our curriculum if you are interested in a complete course.

Clojure is a dynamic language for the Java Virtual Machine with several powerful features for building concurrent applications. In this talk you will learn about:

• Functional programming. Clojure's immutable, persistent data structures encourage side-effect free programming that can easily scales across multiple processor cores.
• Software Transactional Memory (STM). STM provides a mechanism for managing references and updates across threads that is easier to use and less error-prone than lock-based concurrency.
• Agents. Agents provide a thread-safe mechanism for asynchronous, uncoordinated updates.
• Atoms. Atoms provide for synchronous, uncoordinated updates.
• Dynamic Vars. Dynamic Vars support thread-local state.
• Direct access to Java. Clojure calls Java directly, and can emit the same byte code that a handcrafted Java program would. Where it makes sense to do so, you can easily access the java.util.concurrent library.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Concurrent Programming with Clojure" for your organization, or view our curriculum if you are interested in a complete course.

Programming concurrency is hard, but the Java.next languages can make things easier. In this talk (Part 4 of the Java.next series), I will demonstrate how to write concurrent applications in Clojure, Groovy, JRuby, and Scala.

Topics will include

• calling the java.util.concurrent APIs
• why locks are harmful
• using immutable objects
• Scala's actor model
• Clojure's Software Transactional Memory and Agents

For more information, see the following article on the Relevance blog:

• Java.next #4: Immutability

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next Presentation #4: Concurrency" for your organization, or view our curriculum if you are interested in a complete course.

Dispatch takes many forms. Single dispatch, switch statements, pattern matching, and multiple dispatch all meet similar needs: Selecting runtime behavior in response to varying runtime conditions.

Flexible dispatch is a key element of Java.next. All of the Java.next languages support dispatch strategies that are far more flexible than Java's single dispatch.

In this talk (Part 3 of the Java.next series), I will explore how the Java.next languages (Clojure, Groovy, JRuby, and Scala) support dispatch. For more information, see the Java.next Dispatch article on the Relevance blog.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next Presentation #3: Dispatch" for your organization, or view our curriculum if you are interested in a complete course.

The nature of application development has swung away from large, tightly integrated (some might say “coupled”) behemoths into loose collections of highly-granular functionality. This is true both within an application, through tools like Ruby’s metaprogramming facilities and flexible typing, and among a suite of applications, enabled by single-sign-on security architectures and widely available robust messaging providers. This talk will demonstrate these techniques and look at the benefits of this application style, from maintainability, testability, to scalability and sanity. This talk is code-heavy, slide-light, and requires the attendee to have a firm grasp of Ruby, Rails, and patterns of application architecture.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Small Things, Loosely Joined, Written Fast" for your organization, or view our curriculum if you are interested in a complete course.

Domain-Specific Languages (DSLs) have hit the sweet spot on the hype cycle. We now hear potential clients say things like:

Our proposed killer app will target (some domain they don't understand). Step 1: Write a DSL. Step 2. ? Step 3. Profit!

DSLs are very useful, but they are no substitute for good domain design... or good code for that matter. In this talk, we will compare DSLs with other analysis and implementation tools, and help you decide when and how they are a good fit. Along the way we will discuss:

• Good API design
• Declarative style
• Mini-DSLs
• Internal DSls
• External DSLs
• User Interfaces

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Do I Really Need a DSL?" for your organization, or view our curriculum if you are interested in a complete course.

In recent years, the Java community has embraced a variety of new languages that target the JVM, but also offer productivity advantages over traditional Java coding.

One of the most interesting of these languages is Clojure, a "Lisp unconstrained by backward compatibility." In this talk, you will see why Clojure deserves serious consideration as the next big JVM language:

• Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python.
• Clojure's sequence library turns the tables on OO, providing a powerful set of verbs that can work with a small, standard set of nouns.
• 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.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Clojure" for your organization, or view our curriculum if you are interested in a complete course.

The rise of Ajax and Rich Web Applications, plus the success of dynamic languages, has caused people to revisit the JavaScript language. Now that we take JavaScript seriously as a language, it is time to get serious about the quality of JavaScript code, through refactoring. In this talk, we will approach refactoring JavaScript in three phases:

• Test first, then refactor. Bring JavaScript code under test, so that you can refactor with confidence.
• Refactoring 101. Explore some important refactorings: composed method, extract method, introduce named parameter, and extract object
• Common problems. Work through three problems endemic to legacy JavaScript code: making JavaScript unobtrusive, refactoring to prototype-based inheritance, and refactoring to functional style.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Refactoring JavaScript" for your organization, or view our curriculum if you are interested in a complete course.

Prototype and Scriptaculous provide great functionality out of the box, but once you use them for a while you will probably want a little more. In this talk, we will look at tips and tricks for getting the most out of Prototaculous, plus some other libraries that can play nicely. You will see how to

• test your JavaScript code
• write unobtrusive JavaScript with Low Pro
• perform client-side form validation
• reach scripts across sites (for good, not evil!)
• create charts with the Google Chart API
• use UI components beyond the basics of Scriptaculous

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Prototaculous Tips and Tricks" for your organization, or view our curriculum if you are interested in a complete course.

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 four of the most interesting new 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.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next #1: Clojure, Groovy, JRuby, and Scala" for your organization, or view our curriculum if you are interested in a complete course.

You have probably heard about Git by now, perhaps something along these lines: "Git is a version control system, and it is more powerful than 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 the 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.

The Git community prefers power to ease-of-use, and so Git's user interface and documentation can be intimidating. You will learn the straight and narrow path for common, day-to-day Git operations. You will also learn Git's underlying data model, and get a quick introduction to more advanced concepts like submodules, cherry-picking, and bisection.

As a final bonus, you will see how to use Git on an existing SVN project. You can use Git as your SVN client, and the rest of the team can stay on SVN and not even care.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Git Control of Your Source" for your organization, or view our curriculum if you are interested in a complete course.

With an expressive language such as Groovy or Ruby and with modern test practices, 100% C0 test coverage is readily achievable. But 100% coverage is meaningless without other supporting habits and practices. Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong.

We will look at examples of each of these problems, and show how to prevent them from infecting your project:

• Fragile mocking
• Pair bravado
• The ugly mirror
• Parallel abstraction
• Overspecification
• Underspecification
• Invisible code
• Misplaced exemplar

Updated: Jason Rudolph has written a series of articles that are a companion to this talk.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "How To Fail With 100% Test Coverage" for your organization, or view our curriculum if you are interested in a complete course.

Ruby's dynamic features make it easy to write low-ceremony code. Unlike many languages today, Ruby allows you to

• Override calls to new
• Generate new classes and methods at runtime
• Evaluate code on-the-fly
• Dynamically respond to methods with method_missing
• Create headerless source code files

But you should not be satisfied with these. Ruby's abstractions are neither as rich, nor as composable, as they could be. In this talk, we will look at what's wrong with Ruby. Issues include:

• Unnecessary language features such as class variables
• Syntax variations that require you to overspecify (e.g. instance variables)
• Limitations of Ruby reflection
• Second-class citizens, such as blocks

And, of course, we will show specific, real-world examples where these limitations lead to unmaintainable, legacy code.

Avoid these pitfalls, and your Ruby code will be more maintainable. And you will develop a keen sense of what to look for in Ruby's successor.

Relevance staff deliver technical talks at events around the world. Contact us to schedule "Bad Ruby" for your organization, or view our curriculum if you are interested in a complete course.