A list of talks and speaking events I've given

Here's a curated list of talks I've delivered at software conferences. Slides available on Slideshare

Java Collections: The Force Awakens

A long time ago in a galaxy far, far away...

Java open source developers managed to the see the previously secret plans to the Empire's ultimate weapon, the JAVA™ COLLECTIONS FRAMEWORK.

Evading the dreaded Imperial Starfleet, a group of freedom fighters investigate the performance of the Empire’s most popular weapons: LinkedList, ArrayList and HashMap. In addition, they investigate common developer errors and bugs to help protect their vital software. With this new found knowledge they strike back!

Pursued by the Empire's sinister agents, JDuchess races home aboard her JVM, investigating proposed future changes to the Java Collections and other options such as Immutable Collections which could save her people and restore freedom to the galaxy....

Generics: Past, Present and Future

Generics are one of the most complex features of Java. They are often poorly understood and lead to confusing errors. Unfortunately, it won’t get easier. Java 10, release planned for 2018, extends Generics. It’s now time to understand generics or risk being left behind.

We start by stepping back into the halcyon days of 2004 and explain why generics were introduced in the first place back. We also explain why Java’s implementation is unique compared to similar features in other programming languages.

Then we travel to the present to explaining how to make effective use of Generics. We then explore various entertaining code examples and puzzlers of how Generics are used today.

Finally, this talk sheds light on the planned changes in Java 10 with practical code examples and related ideas from other programming languages. If you ever wanted to understand the buzz around higher kinded types or declaration site variance now is your chance!

Pragmatic Functional Refactoring with Java 8

You may be hearing a lot of buzz around functional programming. For example, Java 8 recently introduced new features (lambda expressions and method references) and APIs (Streams, Optional and CompletableFutures) inspired from functional ideas such as first-class functions, composition and immutability.

However, what does this mean for my existing codebase?

In this talk we show how you can refactor your traditional object-oriented Java to using FP features and APIs from Java 8 in a beneficial manner.

We will discuss:

  • How to adapt to requirement changes using first-class functions
  • How you can enhance code reusability using currying
  • How you can make your code more robust by favouring immutability over mutability
  • How you can design better APIs and reduce unintended null pointer exceptions using an optional data type

Performance from Predictability

These days fast code needs to operate in harmony with its environment. At the deepest level, this means working well with hardware: RAM, disks, and SSDs. A unifying theme is treating memory access patterns in a uniform and predictable way that is sympathetic to the underlying hardware. For example, writing to and reading from RAM and hard disks can be significantly sped up by operating sequentially on the device rather than randomly accessing the data. This session covers why access patterns are important, what kinds of speed gains you can get, and how you can write simple high-level code that works well with these kinds of patterns.

Twins: OOP and FP

Object-Oriented Programming has well established design principles, such as SOLID. For many developers architecture and functional programming are at odds with each other: they don’t know how their existing tricks of the trade convert into functional design. This problem becomes worse as hybrid languages such as Scala, Java 8 and Ruby become common. I will talk about how functional programming helps you implement the SOLID principles, and how a functional mindset can actually help you achieve the holy grail of OO, encapsulation.

Presented with Martijn Verburg At:

The Bleeding Edge

Enterprise Java developers value reliability and stability, but what happens to your technology stack if you’re willing to take a risk? At jClarity we’re running production systems using Html 5, Angular.js, vertx, Mongo, groovy and deploying using chef. Its been an interesting ride: some things worked really well and some things don’t.

Come along and find out what we’d recommend and what we’d avoid with hindsight. We’ll also talk about how we ended up with such a diverse stack and how to make technology choices in a fairer way. We’ve made the mistakes so you don’t have to.

Presented At:

Caching In: Understand, Measure and Use your CPU cache more effectively

Modern computationally intensive tasks are rarely bottlenecked on the absolute performance of your processor cores, the real bottleneck in 2013 is getting data out of memory. CPU Caches are designed to alleviate the difference in performance between CPU Core Clockspeed and main memory clockspeed, but developers rarely understand how this interaction works or how to measure or tune their application accordingly.

This Talk solves that by:

  1. Describing how the CPU caches work in the latest Intel Hardware.
  2. Showing people what and how to measure in order to understand the caching behaviour of their software.
  3. Giving examples of how this affects Java Program performance and what can be done to address things.
  4. Talking about what future versions of Java may do to help.

Lambda Expressions: Myths and Mistakes

tl;dr - How will the everyday developer cope with Java 8’s Language changes?

Java 8 will ship with a powerful new abstraction - Lambda Expressions (aka Closures) and a completely retooled set of Collections libraries. In addition interfaces have changed through the addition of default and static methods. The ongoing debate as to whether Java should include such language changes has resulted in many vocal opinions being espoused. Sadly few of these opinions have been backed up by practical experimentation and experience.

  • Are these opinions just myths?
  • What mistakes does a developer make?
  • Can a ‘blue collar’ Java Developer cope with functional programming?
  • Can we avoid these mistakes in future?

Presented with John Oliver At:

Are you better than a Coin Toss?

So you’re a big data and distributed systems “expert”, you’ve collected 500 billion data points, thrown it into sci-lib-of-the-week, you’re using Hadoop, backing onto those cool AWS GPU instances, let it grind away for days and its spit out the answer to life the universe and everything. But is it really better than a coin toss?

How do you validate whether your data analysis algorithm works? Are you learning a solution to your problems or just the data you already have? What problems can you encounter when analysing your data? How do you solve them, and what can you do easily under the time pressures of a business environment?