Not everyone has the possibility of working on Greenfield projects or doing TDD or BDD. Many of us often end up having to work with legacy code bases that have little notion of what SOLID design principles are and unit tests are non-existent.

It can be daunting to have to maintain these types of systems. However, with a little bit of effort, we can try and make the best of the situation. By applying a series of patterns, techniques and principles, we can gradually refactor legacy systems to produce a better, friendlier and more sustainable design. Come and find out how!

Understanding how the brain works and building machines that work on the same principles is one of the greatest quests of our time. In this talk I will describe recent advances in neocortical theory, including why the brain uses sparse distributed representations and how the brain makes predictions from high velocity sensory data streams.

I will demonstrate a product called Grok, that uses a detailed model of neocortical memory to act on machine generated data and how developers can contribute to the development of intelligent machines via the NuPIC open source project (www.numenta.org).

I will end my talk with a discussion of the future of machine intelligence.

The SOLID principles are often presented as being core to good code design practice. Each of S, O, L, I and D do not, however, necessarily mean what programmers expect they mean or are taught. By understanding this range of beliefs we can learn more about practices for objects, components and interfaces than just S, O, L, I and D.

This talk reviews the SOLID principles and reveals contradictions and different interpretations. It is through paradoxes and surprises we often gain insights. We will leave SOLID slightly more fluid, but having learnt from them more than expected.

BDD is a set of practices which help software development teams to have conversations about the behavior of their system and how it delivers value to the project stakeholders. BDD has changed from its early roots as a replacement to TDD and now works as a mini-methodology across the whole software lifecycle. Over the last few years the adoption of BDD has grown globally, with dozens of tools created, used by hundreds of projects around the world.

In this talk we look at the original reasons behind the creation of BDD, bringing the focus back to the language and conversations which lie at its heart. We look at how BDD’s patterns can be applied at multiple scales – from the initial project vision all the way to the code – to deliberately discover and address uncertainty and risk in every aspect of software development, producing reliable, maintainable software that matters.

How to manage and balance all the future features, some architectural work, defect corrections and a growing technical debt. We present a simple strategy based on four colours to help putting it all in the same frame of reasoning, in a single backlog, with some détours about the real nature of technical debt, about value versus cost, the old concept of earned-value, your velocity, and risks and uncertainties.

Mobile is on the rise, and with it comes mobile web technology. The past year has seen tremendous adoption of the free/open source PhoneGap project with over 1 million downloads. Building fast and clean apps has never been easier thanks to a new CSS library from Adobe called Topcoat.

In this talk, Brian will demonstrate how to quickly build a mobile application using PhoneGap with Topcoat, how it all works under the hood, how it relates to Apache Cordova, and where the project is going in the coming year.

This talk covers 3 different functional programmers’ experiences applying Functional Programming in industrial settings; A product company improving their process and success, a new team with new projects, and a team performing experiments with multiple implementations using FP and non-FP languages. There have been some impressive results, and some interesting challenges. We hope these stories inform and inspire you if you are interested in adoption FP in your organisation.

Team 1: A new project, and a new team, is theoretically an ideal time to start using functional programming – green fields. Michael had to good fortune to be a co-founding engineer where the teams were built from the grown up, and projects split off organically. Hyper-small teams (1 or 2 people) and FP (Scala and Erlang, mainly) with the so-called micro-services approach allowed this to work – and scale reasonably well as teams grew. There have been trade offs, but using FP has enabled a breadth of features to be implemented via very small teams. Michael will talk about these trade offs and benefits as his portion of the talk

Team 2: ThoughtWorks has been engaged by IOOF to assist them in building superannuation integration solutions. Korny will talk about how ThoughtWorks and IOOF ran an initial three week experiment to evaluate functional programming languages, using a range of objective and subjective metrics. Based on the results of that experiment, the team developed their integration system in Clojure – Korny will also talk about how the adoption went, and how Clojure was a key factor that allowed them to meet tight deadlines in spite of multiple requirement changes.

Team 3: Atlassian products have to run in all manner of environments, with tens of thousands of customers running every possible combination of hardware, OS, DB and more. Functional programming techniques have proved useful to tame the complexity, and now serious FP projects are underway and gaining momentum. Jed relates the challenges, the pitfalls and the successes that have come with introducing FP to Atlassian.

One of the scenarios described is likely to apply to you – we hope you can take this experience back to your organisation and look at ways you can introduce functional programming based on these lessons learned.

So you’ve heard about the buzz behind Microservices and finer-grained architectures in general? Microservice architectures can lead to easier to change, more maintainable systems which can be more secure, performant and stable than previous designs.

But what are the practical concerns associated with running more fine-grained systems, and what are the new things you’ll need to know if you want to embrace the power of smaller services without the new sources of complexity making your life a nightmare?

This talk will delve deeper into the characteristics of well-behaved services, and will define some clear principles your services should follow. It will also discuss in more depth some of the challenges associated with managing and monitoring more complex distributed systems. We’ll discuss how you can design services to be more fault-tolerant, what technologies may exist in your own platform to get you started. We’ll end by giving some pointers as to when you should consider microservice architectures, and how you should go about introducing them in your own organisation.

The Java platform has grown and evolved in many ways over the past 15 years, and the JVM has become a ubiquitous platform for new languages, high performance computation, and big data processing. But there’s a lot more the JVM could do and more we can make of it.

In this talk we’ll explore key directions the JVM must evolve… via support for alternative languages, integration with native libraries, and optimization strategies. You’ll learn how you can push the JVM beyond its limits today and we’ll discuss ways the JVM will be altered and improved in the future.

It has been five years since Patrick Debois coined the term DevOps to describe a way of working together to deliver systems. In that time, we have rediscovered some gems from the past and we have invented new techniques and tools. In this session, we will take a look at what’s new in the world of DevOps, what’s old-but-good, and where we still need to advance.

If you’re looking for simple solutions for building successful products, you won’t find them in this talk. This is the talk about how hard it really is to succeed, and how the best way to succeed is to ignore the best practice and avoid playing it safe.

In this talk, you’ll hear about companies that started with the best of intentions. But in the end, deliberately broke their process and learned a few counter-intuitive things along the way: The most user-centric companies learned to lie to their customers, skip research, trust their guesses, and stop worrying about usability. The most agile companies learned to deliberately ship bad code, and to stop planning more than a few hours in advance. Design Thinking advocates adopted Lean Startup thinking. And, Lean Startup advocates adopted Design Thinking. In the end the most successful companies end up with a process soup that’s not true to any single process style, and definitely not simple to explain to anyone. They learned that to really win the product development game, they’ve got to worry a lot less about safely delivering on time.

If you attend, you might end up with a few clever ideas to try in your organization. But what I hope you take away is a willingness to abandon the false security of any process approach, keep the best ideas and abandon the rest to focus on succeeding in spite of your process.

A few billion likes and a few hundred million photos uploaded a day. A hundred or so petabytes of queryable data and a handful of power hungry datacenters. And it’s all humming while code is being written and deployed twice daily without our users noticing. This talk will explore the “move fast” side of Facebook’s software engineering culture: development process, organizational structure and the vast amounts of tooling we use to make sure we don’t screw up. We’ll also dig into how we “ship things”: release process, A/B testing, gate keepers, test infrastructure and so on. You’ll walk away with a prospective of how we build software at scale, for scale.

This talk covers 3 different functional programmers’ experiences applying Functional Programming in industrial settings; A product company improving their process and success, a new team with new projects, and a team performing experiments with multiple implementations using FP and non-FP languages. There have been some impressive results, and some interesting challenges. We hope these stories inform and inspire you if you are interested in adoption FP in your organisation.

Team 1: A new project, and a new team, is theoretically an ideal time to start using functional programming – green fields. Michael had to good fortune to be a co-founding engineer where the teams were built from the grown up, and projects split off organically. Hyper-small teams (1 or 2 people) and FP (Scala and Erlang, mainly) with the so-called micro-services approach allowed this to work – and scale reasonably well as teams grew. There have been trade offs, but using FP has enabled a breadth of features to be implemented via very small teams. Michael will talk about these trade offs and benefits as his portion of the talk

Team 2: ThoughtWorks has been engaged by IOOF to assist them in building superannuation integration solutions. Korny will talk about how ThoughtWorks and IOOF ran an initial three week experiment to evaluate functional programming languages, using a range of objective and subjective metrics. Based on the results of that experiment, the team developed their integration system in Clojure – Korny will also talk about how the adoption went, and how Clojure was a key factor that allowed them to meet tight deadlines in spite of multiple requirement changes.

Team 3: Atlassian products have to run in all manner of environments, with tens of thousands of customers running every possible combination of hardware, OS, DB and more. Functional programming techniques have proved useful to tame the complexity, and now serious FP projects are underway and gaining momentum. Jed relates the challenges, the pitfalls and the successes that have come with introducing FP to Atlassian.

One of the scenarios described is likely to apply to you – we hope you can take this experience back to your organisation and look at ways you can introduce functional programming based on these lessons learned.

I bet you’ve been writing JS for years and you think you’re pretty good at it. I bet you think you know all about how functions create closured scope, and how this gets bound, and even how .prototype works. Or, rather, you probably don’t care because your framework or library takes care of all that for you.

JavaScript is generally considered one of the most misunderstood (and maligned) languages of the modern programming era. And there’s good reason for that, because most developers who write JS never actually deeply know how the language works. They blame all their WTFs on language bugs, instead of the shortcomings in understanding.

This talk is going to re-visit some of the “tough parts” of the language by declaring “New Rules” (Bill Maher style) for the language. For instance: “new rule: Stop using this until you fully understand how it gets assigned.”

This talk is going to be hard-core on coding and expects a solid understanding of the language.

The act of programming is typically removed from a program’s ongoing execution, both temporally and spatially. This is particularly true for real-time systems, where the system’s operation is often tightly coupled with the physical environment. This talk aims to challenge this separation by looking at programming as the ongoing orchestration of real-time processes through time – an ongoing cyber-physical dialogue between the programmer, the machine and the environment.

After a very brief history of live coding Andrew’s talk will delve into some of the deeper technical issues surrounding this challenging domain.

Using Andrew’s Extempore system, this talk will explore notions of time, liveness, feedback and procedural orchestration, addressing these ideas from the perspective of both end-user programmers as well as system designers.

There are as many types of agile coaches out there as there are flavors of ice cream. And, their levels of leadership maturity and skill can vary just as widely. It can leave one fretting, “What am I really getting when I bring in an agile coach?” or “How do I develop myself as an agile coach?”. In fact, what are the “must have” skills of an agile coach and how can you tell if someone has them?

The Agile Coach Competency Framework is one big clue to answering these questions. Over the past two years, this framework has guided the development of hundreds of agile coaches. Agile managers and champions also use it to obtain “truth in advertising” to hire the right coach at the right time.

We will explore this framework and provide lightening-talk-style case studies that showcase how it has been used in the real world.

“Functional Programming” is the modern received wisdom regarding program and language design. All the cool kids talk about writing code that is “functional” or even “purely functional”. However, functional programming as it is traditionally defined really doesn’t cut the mustard, and if you look at how modern functional architectures are being shaped, everyone seems to have tacitly arrived at the same conclusion: more is needed. In this talk, we will look at how modern functional languages like Scala, Clojure and even Haskell have evolved beyond the simple paradigms of the lambda calculus. We will see how the industry has really moved beyond functional programming and into the realm of something more powerful, more expressive and better suited to the task of large application architecture.

NoSQL is slaying the Relational Database (RDB) dragons with their fast columns, simple key values, graphs, BASE, and schema less features throwing their hooked on ACID SQL row farmers and DBAs into disarray. But Wait! Rumours are emerging of a secret YesSQL tech heading at warp speed to the lucrative Copious Data Galaxy. Is NewSQL just RDB vendor FUD or does the Empire have any hot cool stuff? Attendees may choose be seated in columns or rows according to their preference!

In this talk we look at the exciting evolution of databases taking place to deal the challenge of copious data. Attendees will learn about the innovations of new database technology and the opportunities and challenges for using it in production and analytics applications.

Facebook takes pride in its “move fast” culture, and both PHP and HHVM (HipHop Virtual Machine for PHP) are fundamentally tied to its success. As the Facebook product has evolved, so has it’s underlying web language, with several Facebook specific language and runtime extensions helping it scale in both developer efficiency and execution efficiency. We explore this evolution, and deep dive on our latest language goodness.

For decades we’ve known that modularity, loose coupling, and service orientation allow for the construction of large software systems that can be reasonably maintained and extended. In this talk, Steve explores from a services perspective the architecture of Riak, the open source distributed database from Basho Technologies, focusing on how it achieves fault tolerance and high availability based on modularity, supervision, replication, and message passing between services, as well as how it integrates subsystems written in different programming languages. He also discusses how Erlang, the language used to implement most of Riak, facilitates the construction of service-oriented systems.

For the domain of databases, the old question of how to achieve language integrated query is receiving renewed attention, in part because of its support through Microsoft’s LINQ framework. We present a practical theory of language-integrated query based on quotation and normalisation of quoted terms. Higher-order features prove useful even for constructing first-order queries. We prove a theorem characterising when a host query is guaranteed to generate a single SQL query, and we present experimental results confirming our technique works, even in situations where Microsoft’s LINQ framework either fails to produce an SQL query or, in one case, produces an avalanche of SQL queries. Our ideas are implemented in F#, and the talk briefly considers how they might apply to other languages such as Scala and Haskell.

In this talk we’ll explore powerful analytic techniques for graph data. Firstly we’ll discover some of the innate properties of (social) graphs from fields like anthropology and sociology. By understanding the forces and tensions within the graph structure and applying some graph theory, we’ll be able to predict how the graph will evolve over time. To test just how powerful and accurate graph theory is, we’ll also be able to (retrospectively) predict World War 1 based on a social graph and a few simple mechanical rules.Then we’ll see how graph matching can be used to extract online business intelligence (for powerful retail recommendations). In turn we’ll apply these powerful techniques to modelling domains in Neo4j (a graph database) and show how Neo4j can be used to drive business intelligence. Don’t worry, there won’t be much maths.

This talk covers 3 different functional programmers’ experiences applying Functional Programming in industrial settings; A product company improving their process and success, a new team with new projects, and a team performing experiments with multiple implementations using FP and non-FP languages. There have been some impressive results, and some interesting challenges. We hope these stories inform and inspire you if you are interested in adoption FP in your organisation.

Team 1: A new project, and a new team, is theoretically an ideal time to start using functional programming – green fields. Michael had to good fortune to be a co-founding engineer where the teams were built from the grown up, and projects split off organically. Hyper-small teams (1 or 2 people) and FP (Scala and Erlang, mainly) with the so-called micro-services approach allowed this to work – and scale reasonably well as teams grew. There have been trade offs, but using FP has enabled a breadth of features to be implemented via very small teams. Michael will talk about these trade offs and benefits as his portion of the talk

Team 2: ThoughtWorks has been engaged by IOOF to assist them in building superannuation integration solutions. Korny will talk about how ThoughtWorks and IOOF ran an initial three week experiment to evaluate functional programming languages, using a range of objective and subjective metrics. Based on the results of that experiment, the team developed their integration system in Clojure – Korny will also talk about how the adoption went, and how Clojure was a key factor that allowed them to meet tight deadlines in spite of multiple requirement changes.

Team 3: Atlassian products have to run in all manner of environments, with tens of thousands of customers running every possible combination of hardware, OS, DB and more. Functional programming techniques have proved useful to tame the complexity, and now serious FP projects are underway and gaining momentum. Jed relates the challenges, the pitfalls and the successes that have come with introducing FP to Atlassian.

One of the scenarios described is likely to apply to you – we hope you can take this experience back to your organisation and look at ways you can introduce functional programming based on these lessons learned.

It is often important to look at our past, to understand how we got to where we are. Especially with something that has had such a rocky past. As performance in the browser and javascript VM are often optimised by popular trends and benchmarks how can we ensure our code is not going against the grain and suffering because of it? How will we be writing javascript in the future (if at all)?