Stuart Halloway

By Stuart Halloway

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 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.

By Stuart Halloway

Clojure is 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 data structures encourage side-effect free programming that can easily be shared 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.
* Direct access to Java. Clojure calls Java directly, and can emit the same byte code that a handcrafted Java program would. So, you can easily access the java.util.concurrent library.

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 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 subversion project. You can use git as your svn client, and the rest of the team can stay on svn and not even care.

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
• Setting the wrong kinds of targets
• Holding all participants accountable
• Forking everything
• Introducing new technologies

Hold on tight to your sacred cows, because no assumption you have about agile will be safe.

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 to apply agile at the strategic realm, using practices like:

• measure the immeasurable
• pair everything
• choose meaningful standards
• build for tomorrow (but not next year)
• retrospect well
• spot the trends
• use the right medium
• want to succeed (not as obvious as it sounds!)

With the right practices in place, agility can help you choose objectives, as well as attain them.