Talks

Here is a list of some of the talks I've done.

Effective Code Review

December 2018 @codeid

There are so many benefits from code review; lower development costs, increased code quality, quick up-skilling and on-boarding of team members. Despite these benefits many teams don’t have code review as part of their process at all. Others don’t get the gains they should from it.

This talk first outlines the business case for code review. It then explores how to make code review effective, specifically looking at:

Expectations of what can be achieved with code review.

What should be covered by code review (including example code)

What should not be covered by code review

How to write code that makes code review easy

What makes good code review comments

What makes good responses to code review comments

Finally to wrap up you'll be shown how to enable a code review with Github. Spoiler alert: It can be done it under 5 mins!

So if you are on a team that isn’t using code review, or isn’t using it effectively then you should be at this talk.

Download slides

AssertTrue(isDecoupled("MyTests"))

October 2018 @ipc18

We all know why tests are great. But every once in a while we just wish they’d never been written. One case when test regret occurs is when we want to alter our functionality slightly but in doing so half the test suite goes from green to red.

“Houston we have a problem! This change you want… Well it’s one small change for the codebase but one giant change to the test suite!”

This talk will investigate why this happens. In particular it looks at the coupling between tests and the code under test. We’ll investigate ways we can reduce this coupling and make out test suites more resilient to change.

This talk is aimed at those who already write tests and have a good understanding of SOLID principles.

Download slides

Squash bugs with static analysis

October 2018 @ipc18

All developers know that bugs are bad and finding them can be difficult. The good news is tools to help us find and prevent bugs are becoming more powerful...

Modern static analysis tools (e.g. IDEs like PHPStorm and tools like Psalm, Phan and PHPStan) are far more advanced then their predecessors. They can find a whole range of bugs whilst keeping the false positive rate low.

This talk introduces more advanced static analysis. It will show the kinds of bugs that the more advanced static analysis tools can find. We’ll then look how they can be added to your current development work flow. We’ll finally look at how we can write our code in such a way to get the most out of static analysis.

Download slides

Squash bugs with static analysis

September 2018 @phplondon

All developers know that bugs are bad and finding them can be difficult. The good news is tools to help us find and prevent bugs are becoming more powerful...

Modern static analysis tools (e.g. IDEs like PHPStorm and tools like Psalm, Phan and PHPStan) are far more advanced then their predecessors. They can find a whole range of bugs whilst keeping the false positive rate low.

This talk introduces more advanced static analysis. It will show the kinds of bugs that the more advanced static analysis tools can find. We’ll then look how they can be added to your current development work flow. We’ll finally look at how we can write our code in such a way to get the most out of static analysis.

Download slides

AssertTrue(isDecoupled("MyTests"))

June 2018 @dpc2018

We all know why tests are great. But every once in a while we just wish they’d never been written. One case when test regret occurs is when we want to alter our functionality slightly but in doing so half the test suite goes from green to red.

“Houston we have a problem! This change you want… Well it’s one small change for the codebase but one giant change to the test suite!”

This talk will investigate why this happens. In particular it looks at the coupling between tests and the code under test. We’ll investigate ways we can reduce this coupling and make out test suites more resilient to change.

This talk is aimed at those who already write tests and have a good understanding of SOLID principles.

Download slides | joind.in

Beat the bugs, before they beat you

June 2018 @phptek

This talk will leave you with plenty of tips on how to write cleaner code with fewer bugs. And best of all you can apply them the next time you write code.

"In this world nothing can be said to be certain, except death and taxes."

Software developers have a third certainty. Bugs.

Regardless of experience and skill level, all developers introduce bugs into their code. The longer these bugs fester, the more expensive the consequences of them become. So to improve the quality of our software we need to find bugs fast, ideally before they even end up entering the codebase.

This talk is aimed at beginner to intermediate level software developers. It introduces the concepts: type hints, assertions and value objects.

We'll then look at how these techniques can be combined with modern IDEs to: reduce the chance of introducing bugs, minimising the cost associated with any bugs that do slip through the net, safely refactor code so we can rename classes, methods and variables to be more explicit

Download slides | joind.in

Effective Code Review (PHP[Tek] Conference)

May 2018 @phptek

There are so many benefits from code review; lower development costs, increased code quality, quick up-skilling and on-boarding of team members. Despite these benefits many teams don’t have code review as part of their process at all. Others don’t get the gains they should from it.

This talk first outlines the business case for code review. It then explores how to make code review effective, specifically looking at:

Expectations of what can be achieved with code review.

What should be covered by code review (including example code)

What should not be covered by code review

How to write code that makes code review easy

What makes good code review comments

What makes good responses to code review comments

Finally to wrap up you'll be shown how to enable a code review with Github. Spoiler alert: It can be done it under 5 mins!

So if you are on a team that isn’t using code review, or isn’t using it effectively then you should be at this talk.

Download slides | joind.in

Effective Code Review (phpday Conference)

May 2018 @phpday

There are so many benefits from code review; lower development costs, increased code quality, quick up-skilling and on-boarding of team members. Despite these benefits many teams don’t have code review as part of their process at all. Others don’t get the gains they should from it.

This talk first outlines the business case for code review. It then explores how to make code review effective, specifically looking at:

Expectations of what can be achieved with code review.

What should be covered by code review (including example code)

What should not be covered by code review

How to write code that makes code review easy

What makes good code review comments

What makes good responses to code review comments

Finally to wrap up you'll be shown how to enable a code review with Github. Spoiler alert: It can be done it under 5 mins!

So if you are on a team that isn’t using code review, or isn’t using it effectively then you should be at this talk.

Download slides | joind.in

AssertTrue(isDecoupled("MyTests"))

May 2018 @phpnw

We all know why tests are great. But every once in a while we just wish they’d never been written. One case when test regret occurs is when we want to alter our functionality slightly but in doing so half the test suite goes from green to red.

“Houston we have a problem! This change you want… Well it’s one small change for the codebase but one giant change to the test suite!”

This talk will investigate why this happens. In particular it looks at the coupling between tests and the code under test. We’ll investigate ways we can reduce this coupling and make out test suites more resilient to change.

This talk is aimed at those who already write tests and have a good understanding of SOLID principles.

Download slides

Effective Code Review (PHP-SW user group)

April 2018 @phpsw

There are so many benefits from code review; lower development costs, increased code quality, quick up-skilling and on-boarding of team members. Despite these benefits many teams don’t have code review as part of their process at all. Others don’t get the gains they should from it.

This talk first outlines the business case for code review. It then explores how to make code review effective, specifically looking at:

Expectations of what can be achieved with code review.

What should be covered by code review (including example code)

What should not be covered by code review

How to write code that makes code review easy

What makes good code review comments

What makes good responses to code review comments

Finally to wrap up you'll be shown how to enable a code review with Github. Spoiler alert: It can be done it under 5 mins!

So if you are on a team that isn’t using code review, or isn’t using it effectively then you should be at this talk.

Download slides | joind.in

Beat the bugs, before they beat you

April 2018 @php-berkshire

This talk will leave you with plenty of tips on how to write cleaner code with fewer bugs. And best of all you can apply them the next time you write code.

"In this world nothing can be said to be certain, except death and taxes."

Software developers have a third certainty. Bugs.

Regardless of experience and skill level, all developers introduce bugs into their code. The longer these bugs fester, the more expensive the consequences of them become. So to improve the quality of our software we need to find bugs fast, ideally before they even end up entering the codebase.

This talk is aimed at beginner to intermediate level software developers. It introduces the concepts: type hints, assertions and value objects.

We'll then look at how these techniques can be combined with modern IDEs to: reduce the chance of introducing bugs, minimising the cost associated with any bugs that do slip through the net, safely refactor code so we can rename classes, methods and variables to be more explicit

Download slides

The Test Suite Holy Trinity (Benelux Conference)

January 2018 @phpbenelux

What would the perfect test suite look like? Well it would definitely fully test every bit of functionality. It would run lightning fast. And the test suite would be quick to write. That sounds great right?

Unfortunately these 3 goals work against each other. Increasing test coverage will increase the time spent writing and executing tests. Reducing test execution time will result in lower coverage.

This talk look at the properties of unit, integration and system tests in terms of what they test, how fast they run and how quick they are to write. Will look at how to get the most out of testing at each of these levels, how best to architect code for testing and where best to make comprises.
 Although by the end of the talk we won’t have quite achieved the Test Suite Holy Trinity, we’ll be a step closer.

Download slides | joind.in

The Test Suite Holy Trinity (Newcastle user group)

January 2018 @phpne

What would the perfect test suite look like? Well it would definitely fully test every bit of functionality. It would run lightning fast. And the test suite would be quick to write. That sounds great right?

Unfortunately these 3 goals work against each other. Increasing test coverage will increase the time spent writing and executing tests. Reducing test execution time will result in lower coverage.

This talk look at the properties of unit, integration and system tests in terms of what they test, how fast they run and how quick they are to write. Will look at how to get the most out of testing at each of these levels, how best to architect code for testing and where best to make comprises.
 Although by the end of the talk we won’t have quite achieved the Test Suite Holy Trinity, we’ll be a step closer.

Download slides

The Test Suite Holy Trinity (Brighton user group)

January 2018 @phpbrighton

What would the perfect test suite look like? Well it would definitely fully test every bit of functionality. It would run lightning fast. And the test suite would be quick to write. That sounds great right?

Unfortunately these 3 goals work against each other. Increasing test coverage will increase the time spent writing and executing tests. Reducing test execution time will result in lower coverage.

This talk look at the properties of unit, integration and system tests in terms of what they test, how fast they run and how quick they are to write. Will look at how to get the most out of testing at each of these levels, how best to architect code for testing and where best to make comprises.
 Although by the end of the talk we won’t have quite achieved the Test Suite Holy Trinity, we’ll be a step closer.

Download slides

The Test Suite Holy Trinity (Dorset user group)

January 2018 @phpdorset

What would the perfect test suite look like? Well it would definitely fully test every bit of functionality. It would run lightning fast. And the test suite would be quick to write. That sounds great right?

Unfortunately these 3 goals work against each other. Increasing test coverage will increase the time spent writing and executing tests. Reducing test execution time will result in lower coverage.

This talk look at the properties of unit, integration and system tests in terms of what they test, how fast they run and how quick they are to write. Will look at how to get the most out of testing at each of these levels, how best to architect code for testing and where best to make comprises.
 Although by the end of the talk we won’t have quite achieved the Test Suite Holy Trinity, we’ll be a step closer.

Download slides

The Git Eureka moment

November 2018 @phpberks

Let me share my git eureka moment with you. The moment when suddenly everything git related made sense.
We’ll delve just below the surface to understand what commits and branch really are. With these concepts cemented we’ll look at some of git’s more advanced features.

Is git just gobbledygook to you?

Do you run commands blindly hoping for the best?

Do warnings of detached heads leave you distraught?

In that case let me share my git eureka moment with you. The moment when suddenly everything git related made sense.
We’ll delve just below the surface to understand what commits and branch really are. With these concepts cemented we’ll look at some of git’s more advanced features.

Soon you'll be relishing rebases, comfortable with commit amends and relieved you know all about reflog.

Download slides

Beat the bugs, before they beat you

September 2017 @phpem

This talk will leave you with plenty of tips on how to write cleaner code with fewer bugs. And best of all you can apply them the next time you write code.

"In this world nothing can be said to be certain, except death and taxes."

Software developers have a third certainty. Bugs.

Regardless of experience and skill level, all developers introduce bugs into their code. The longer these bugs fester, the more expensive the consequences of them become. So to improve the quality of our software we need to find bugs fast, ideally before they even end up entering the codebase.

This talk is aimed at beginner to intermediate level software developers. It introduces the concepts: type hints, assertions and value objects.

We'll then look at how these techniques can be combined with modern IDEs to: reduce the chance of introducing bugs, minimising the cost associated with any bugs that do slip through the net, safely refactor code so we can rename classes, methods and variables to be more explicit

Download slides | joind.in

Code review and CI in your lunch break

July 2017 @php-oxford

Code review and CI are vitial parts of the modern software development process. It also dead easy to set these up for your project. Find out why and how in this talk

In the past you might just about be forgiven for not setting these tools up (ask anyone who's lost days configuring tools like Gerrit). However today there is no excuse. Bitbucket and Github both offer code review out of the box. They are so simple to setup you could be up and running in your lunch hour and still have time for lunch.

This talk we outline the benefits of code review, how to conduct effective code review. . It'll talk about concepts like pull requests and protected branches and why they are important. It'll take you through (in a series of screenshots) how to setup Github with CircleCI.

We'll also look at a few tools like Coding standard fixers, linters, var dump checkers and how to weave them into your development process.

Download slides

Is what you've coded what you mean?

July 2017 @DrupalCampBris

This talk explores how do you reduce the number of bugs in your codebase and how do you limit the impact of these bugs?

Imagine a venn diagram of your last software project. Consider three parts: what the code should do, what the code actually does and what the developers think the code does. The greater the overlap the more successful and bug free your software is likely to be.

This talk examines how to increase this overlap. We'll look at the importance of type hinting, assertions and things called value objects. We'll then look at how these techniques can be combined with modern IDEs.

By the end of the talk you'll have picked up tips on how to write cleaner software with fewer bugs that does what it's supposed to do.

Download slides | joind.in

Is what you've coded what you mean?

June 2017 @phpwarks

This talk explores how do you reduce the number of bugs in your codebase and how do you limit the impact of these bugs?

Imagine a venn diagram of your last software project. Consider three parts: what the code should do, what the code actually does and what the developers think the code does. The greater the overlap the more successful and bug free your software is likely to be.

This talk examines how to increase this overlap. We'll look at the importance of type hinting, assertions and things called value objects. We'll then look at how these techniques can be combined with modern IDEs.

By the end of the talk you'll have picked up tips on how to write cleaner software with fewer bugs that does what it's supposed to do.

Download slides | joind.in

Don't be so primitive

May 2017 @phpsw

A quick look at Value Objects, what they are, the benefits they offer and why sometimes they should be used instead of PHP’s primitive types.

Download slides | Watch

The Test Suite Holy Trinity

April 2017 @phphants

The ideal test suite would test everything, be quick to write and would run lighting fast. This talk looks at how this can be achieved.

Download slides

Introduction to Bash

March 2017 @Bristol PHP training & CodeHub Bristol

Workshop providing an introduction to shell scripting with Bash.

Download slides

Decoupling with Events

October 2016 @phpsw

All developers should be writing decoupled code. Decoupled code is easier to understand, test and extend. This talk looks at how you can use events for decoupling.

This talk looks at a couple of examples of how events can help decouple code.

Download slides | Watch

Beyond Unit Testing

February 2016 @phpsw

Unit testing is an essential part of any successful software project, but it's only half the testing story. This talk will examine the other half of the testing story. We'll see why we need more than just unit tests and how to write these extra tests.

Download slides | Watch | joind.in

Code reivew with Gerrit (Lightning talk)

October 2015 @phpsw

Quick introduction to integrating code review using Gerrit into your workflow.

Download slides

Semantic versioning (Lightning talk)

October 2014 @phpsw

Guide to Semantic versioning and why it should be used.

Design for testability

August 2014 @phpsw

Testing code is difficult right? Not if you design your code with testability in mind. Learn how with this talk

Testable code goes hand in hand with best practice. Well written code is easy to test, extend and understand. Making your code easy to testable makes your code easy to work with.

Download slides