Monday, 9th - Tuesday, 10th December in Online Event

40 experts spoke.
Overview

YOW! Conference is designed by developers for developers, and each speaker has been invited because of their development expertise by our independent international program committee. At YOW! Conference you'll get straight tech talk by world-class experts and networking with like-minded developers.

Excited? Share it!

Programme

Hiring (or Growing) the Right Agile Coach

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.



Lyssa Adkins

Founder
Agile Coaching Institute


Solving the Hard Problem of Concurrency

Concurrency is notorious for creating complexity. I argue that the blame lies not with multithreading, mutability, or even shared writable state. The problem is one of separation: an inability to isolate concurrency logic from application logic. The cause of this inability is twofold. First, we tend to overlook the distinction between concurrency concerns and time-based concerns. Consequently, we end up with too much (complex) concurrency code and not enough (simple) temporal code. Second, there’s been a historical lack of abstractive power in mainstream programming languages. To isolate structured and unstructured concurrency, we need a language that supports type amplification, futures and time travel. The good news is that a mainstream language now supports all three: C# 5.

In this session, I will explain these concepts, and demonstrate how C# 5 simplifies asynchrony and concurrency.



Joe Albahari

.NET Developer
LINQPad


Disruptor 3.0: Details and Advanced Patterns

Even a tool, like the Disruptor, that comes out of the box with great performance, it is possible to apply an understanding of the problem and a some mechanical sympathy to make the software run even faster. In this talk I will demonstrate an advanced technique of applying the Disruptor to two specific, but very common use cases to improve throughput and decrease latency. The cover of the CPU will be lifted to examine a number of hardware metrics with the intention of understanding where the additional performance comes from.



Michael Barker

Michael Barker is currently a lead developer at London Multi-Asset eXchange (LMAX) where he spends most of his time scratching his head while thinking about simpler and faster solutions.


Repsheet: A Behavior Based Approach to Web Application Security

The world of information security is changing in dramatic ways. In order to keep up with the demands of users and drive innovation, we have to start taking new approaches to securing our web applications. This means enabling increased security while decreasing friction for known good users. In order to make this happen it requires dynamic security controls. It means deriving intent through behavior. This approach not only makes for a more enjoyable experience for good users, it helps spot attacks in progress and trend developing threats such as botnets and DDoS attacks.

Join Aaron Bedra as he walks you through asking the questions you should be asking of your users activity, and how to help prevent abuse, fraud, and otherwise unwanted activity on your web applications while decreasing friction for good users. You will learn how to ask the right questions without interfering with a great user experience.



Aaron Bedra

Aaron Bedra has served as a Chief Security Officer, Chief Technology Officer, Chief Scientist and Principal Engineer/Architect. He currently works at the intersection of trading + technology as a senior software engineer at DRW.

Aaron has worked professionally on programming languages, most notably Clojure and ClojureScript. He is the creator of Repsheet, an open source threat intelligence toolkit; is the co-author of Programming Clojure, 2nd and 3rd Edition and a contributor to Functional Programming: A PragPub Anthology.

Aaron blogs about software and security at aaronbedra.com


Explorations in Next Generation Web Languages

A successful commercial programming language must be instantly familiar to its target audience. It must be engineered to deal with the challenges of todays systems. It must innovate and yet not over innovate. Dart, Google’s new web language, follows this approach and provides high performance on today’s web browsers. In contrast, Newspeak is a work of uncompromising idealism implemented on a figurative shoestring. Yet both languages share a common philosophy favoring pure object orientation and network awareness. Both languages support variations on features such as mirror based reflection, actor based concurrency, optional types and mixins. In this talk, we’ll compare the two languages/platforms and discuss why and how specific differences arose despite the commonality.



Gilad Bracha

Developer
Google


Creating Observable APIs with Rx

Learn how functional reactive programming styles are used by Netflix to create “Observable APIs” and implement concurrent web services against asynchronous data sources without blocking, synchronization or thread-safety concerns by using declarative functional reactive composition.

To achieve this Netflix ported Rx from .Net to the JVM and open sourced it as RxJava (http://techblog.netflix.com/2013/02/rxjava-netflix-api.html). It is a library for composing asynchronous and event-based programs using observable sequences for the Java VM that supports Java 6+, Clojure, Scala, Groovy, JRuby and Java 8 lambdas.

Come see what functional reactive programming looks like, what use cases it addresses and real-world examples of how it can become a tool in your application development.



Ben Christensen

software engineer
Netflix Edge Services


Cloud Native Architecture at Netflix

Netflix optimizes for speed of development and high availability. Our cloud native architecture has developers running what they wrote and deploying code continuously using tooling and and patterns that minimize the impact of any production issues, and provide rapid visibility and automated response to reduce exposure. The Netflix platform has been released as a collection of open source components at http://netflix.github.com so that others can embrace and extend it.



Adrian Cockcroft

Adrian Cockcroft has had a long career working at the leading edge of technology, and is fascinated by what happens next. In his new role as VP Sustainability Architecture at Amazon he is developing and sharing best practices for sustainable product architectures, and working with teams across AWS to support their own sustainability programs.


The World’s Most Misunderstood Programming Language

JavaScript has become important and ubiquitous. There are more people writing JavaScript than any other language. The language is surprisingly powerful, but comes with virtually no guard rails or safety devices. It is possible to write JavaScript in the style of other languages, but that can quickly lead to code that is difficult to maintain. By understanding how this language actually works, and by working with the language’s grain, you can be more productive and happier.



Douglas Crockford

Douglas Crockford is the creator of JSON and works at Paypal.

Douglas was born in the wilds of Minnesota, but left when he was only six months old because it was just too damn cold. He turned his back on a promising career in television when he discovered computers. He has worked in learning systems, small business systems, office automation, games, interactive music, multimedia, location-based entertainment, social systems, and programming languages.


Devops Modelling (Theory, Practice and Caveats)

There is no official “devops” Manifesto. I’ve always shied away from writing this for two main reasons:

  • not setting things in stone encourages people to keep an open mind. So they can come with their own version of the solution AND the problem. This allows our field to expand and have people re-think and re-evaluate other people’s solutions.
  • it often brings a sense of checklist. Do A,B,C and you have reached the final goal. Devops does not have an end-goal, it is continuous journey; whatever you change to improve, will have an impact and might require you re-think your strategy

Therefore I value more the different models people have developed along the years to understand/explain the “devops” problem space:

In the first part of the session, I will iterate over the conceptual models I’ve come across that try to capture the essence of devops. In part two we will leave the theory, and provide a more practical way of obtaining the shared view, using a sort of ‘reverse value stream mapping’ technique. Finally, we’ll take a step back and see how well we’ve done in the past years, explain some of the caveats and look towards the future.

Don’t expect specific tools to be explained in full; We will refer to the tools as examples of concepts though. Come with an open mind and re-think / re-evaluate your “devops” project while applying the principles of the different models.



Patrick Debois

In order to understand current IT organizations, Patrick has taken a habit of changing both his consultancy role and the domain which he works in: sometimes as a developer, manager, sysadmin, tester and even as the customer.


Google Earth Engine: Enabling Science with Novel Software

Earth Engine (http://earthengine.google.org/) is an experimental platform for environmental analysis, providing petabytes of data and an API suitable both for exploratory programming and very large scale batch processing. Our science partners are using it to detect illegal logging in the Amazon, build global maps of land use, estimate forest biomass and carbon, and map the world’s roadless areas.



Mike Dixon

Global Visual Analytics
Google Earth Engine


Focusing the Core Domain: Domain-Driven Design Case Study

This talk tells a true story with a thin disguise. (The company involved does not want some details known.) Two years ago, a team I work with developed an application that addressed a strategically important pain-point. This is the story of how we used the Strategic Design tools of DDD to decide what to do, and how we ultimately turned it into a simple problem by leveraging established formalisms to do something quite original.



Eric Evans

Eric Evans, author of Domain-driven Design: Tackling Complexity in the Heart of Software is a thought leader in software design, domain driven design and domain modeling and particularly focuses on strategic design.


Setting a Good Example – How to improve your SbE, BDD and ATDD artefacts

To get the most out of Behaviour Driven Development (BDD), Specification by Example (SBE) or Acceptance Test-Driven Development (ATDD), you need much more than a tool. You need high value specifications. How do we get the most out of our specification and test writing effort? How do we write testable scenarios that business people will actually care about? These and other questions will be addressed in this talk in which we take a practical approach using real-world examples.

If you work with Cucumber, Concordion, Fitnesse or similar tools to support BDD and ATDD, you will learn how to avoid common mistakes that teams make when writing test scenarios. You will also learn to recognise the characteristics that take good scenario descriptions beyond the role of acceptance tests and into living documentation for long-term value.



David Evans

David Evans is an independent agile consultant, coach and trainer. He is an evangelist on agile testing, TDD, BDD and Specification by Example, and is a regular speaker at international conferences and seminars.


Lessons Learned from Adopting Clojure

Five years ago DRW Trading was primarily a Java shop, and I was primarily developing in Ruby. Needless to say, it wasn’t a match made in heaven. Fast forward five years, Clojure is the second most used language in the firm, and the primary language for several teams (including mine). Clojure wasn’t the first language that I’ve introduced to an organization; however, it’s unquestionably the most successful adoption I’ve ever been a part of. The use of Clojure has had many impacts on the firm: culturally, politically, and technically. My talk will discuss general ideas around language selection and maintenance trade-offs, and specific examples of what aspects of Clojure made it the correct choice for us.

A few highlights

  • Where to first introduce a new language and your role as the language care-taker.
  • REPL driven development, putting TDD’s ‘rapid feedback’ to shame.
  • Operations impact of adding a language – i.e. get ready for some DevOps.
  • Functional programming, the Lisp Advantage, and their impact on maintainability.

Of course, no good experience report is all roses. The adoption has seen several hurdles along the way, and I’ll happily to describe those as well.



Jay Fields

Jay Fields is the author of Working Effectively with Unit Tests, an author of Refactoring: Ruby Edition, and a Software Engineer at DRW Trading.


What do you Mean, Backwards Compatibility?

The Java driver for MongoDB has been around almost as long as the NoSQL database itself. It was designed without some of the modern Java features we now take for granted, and the API might be easier with features like lambdas.

The existing Java driver is extensively used, which leads to a tricky question: how do you create a new API that uses modern development patterns whilst retaining backwards compatibility? Your users are fundamental to the success of your business, you do not want to alienate them, break their systems or make it hard for them to migrate to the New World Order.

In this presentation Trisha will share some of the pain experienced and solutions tried while creating a new Java driver for MongoDB.



Trisha Gee

Trisha has developed Java applications for a range of industries, including finance, manufacturing, software and non-profit, for companies of all sizes. She has expertise in Java high performance systems, is passionate about enabling developer productivity, and dabbles with Open Source development. Trisha is a leader of the Sevilla Java User Group and a Java Champion, she believes healthy communities and sharing ideas help us to learn from mistakes and build on successes. As a Developer Advocate for JetBrains, she gets to share all the interesting things she’s constantly discovering.


No App Is An Island

Almost all apps rely on APIs, no app is an island, entire of itself. We want to keep our apps slick and simple, pushing complex logic to the server, allowing iOS devs to focus on shiny new user experiences. All the hipster developers are using microservices and deploying to the cloud, but what does that mean for your front end apps and APIs? At realestate.com.au, we’re building simpler apps backed by smarter microservices using REST, hypermedia and HATEOAS, not just object.to_json. This session will demonstrate how to quickly build iOS apps to discover, consume and navigate these services using HAL JSON, and some nifty Objective C libraries for networking and functional-reactive goodness in a way ‘future you’ will be thankful for.



Stewart Gleadow

Sr. Tech Lead
REA Group


Angle Brackets, Curly Braces, JavaScript & Assembler

One day we woke up and things were different. Maybe it happened overnight, maybe it took many years. Suddenly we are scripting against thousands of Virtual Machines from the command line while creating things today with JavaScript in the browser that were impossible yesterday. LiveScript becomes JavaScript becomes ES6 and now we’re compiling C++ to JS. Join Scott Hanselman as he explores the relationship between the Cloud and the Browser, many Languages and one Language, how it might all fit together and what might come next.



Scott Hanselman

Programmer
Microsoft


Refactoring Legacy Codebases

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!



Hadi Hariri

Hadi Hariri is a developer, speaker and Technical Evangelist at JetBrains.


Computing Like the Brain: The Path to Machine Intelligence

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.



Jeff Hawkins

Jeff Hawkins is an engineer, serial entrepreneur, scientist, inventor, and author. He was a founder of two mobile computing companies, Palm and Handspring, and was the architect of many computing products such as the PalmPilot and Treo smartphone.


The SOLID Design Principles Deconstructed

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.



Kevlin Henney

Kevlin Henney is an independent consultant, trainer and author. His interests are in process, practice, patterns and programming.


Handling Uncertainty with Behavior-Driven Development

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.



Liz Keogh

Liz Keogh is a Lean and Agile consultant based in London. She is a well-known blogger and international speaker, a core member of the BDD community and a passionate advocate of the Cynefin framework and of Wardley Mapping.

Liz has a strong technical background with over 20 years’ experience in delivering and coaching others to deliver software, from small start-ups to global enterprises. Most of her work now focuses on Lean, Agile and organizational transformations, and the use of transparency, positive language, well-formed outcomes and safe-to-fail experiments in making change innovative, easy and fun.


What Colours is Your Backlog?

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.



Philippe Kruchten

Professor of Software Engineering
University of British Columbia


Mobile Web Whirlwind Tour of PhoneGap, Cordova & Topcoat

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.



Brian LeRoux

Brian LeRoux leads the open source PhoneGap project team at Adobe (currently undergoing incubation as Apache Cordova). He's been with the PhoneGap project from its very humble beginnings at Nitobi Software.


Industrial Experiences Transitioning to Functional Programming

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.



Michael Neale

Co-Founder
CloudBees


Practical Considerations For Microservice Architectures

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.



Sam Newman

Sam Newman, a techie interested in cloud, continuous delivery and microservices. Aside from other things he's committed sporadically to open source projects, spoke at more than a few conferences, and wrote some things including the book Building Microservices for O'Reilly.


Beyond JVM

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.



Charles Nutter

Charlie Nutter is co-lead on the JRuby project. He went to his first Ruby conference 5 years ago, and liked the language he quickly started


Five Years of DevOps: Where are we Now?

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.



Michael Nygard

Michael has been a professional programmer and architect for over 15 years. In that time, he has delivered systems to the U.S. Government, the military, banking, finance, agriculture, and...


Safety Not Guaranteed: How Successful Teams Ignore the Rules to Create Successful Products

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.



Jeff Patton

Jeff Patton helps companies adopt a way of working that’s focused on building great products, not just building stuff faster. Jeff blends a mixture of Agile thinking, Lean and Lean Startup Thinking, and UX Design and Design Thinking to end up with a holistic product-centric way of working.


Move Fast and Ship Things

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.



Joel Pobar

Engineering Manager
Facebook


Industrial Experiences Transitioning to Functional Programming

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.



Korny Sietsma

Korny works for ThoughtWorks as a developer, consultant and compensating optimist. He has been developing mostly in Clojure for the past 2 years, and in a range of lesser languages for a long time before that.


New Rules For JavaScript

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.



Kyle Simpson

Kyle Simpson is a JavaScript Systems Architect from Austin, TX and co-author of


Programming In Time – Live Coding for Creative Performances

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.



Andrew Sorensen

Director
moso.com.au


Hiring (or Growing) the Right Agile Coach

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.



Michael Spayd

Chief Executive
Agile Coaching Institute


Living in a Post-Functional 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.



Daniel Spiewak

Principal Engineer
Disney Streaming Services


NoSQL & NewSQL – The Empire Strikes Back?

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.



Dave Thomas

Dave is a freelance F# engineer and a Microsoft MVP, formerly with Xamarin.


Moving faster with PHP at Facebook

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.



Julien Verlaguet

Software Engineer
Facebook


Exploring Riak’s Service Architecture

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.



Steve Vinoski

Steve Vinoski is an architect at Basho Technologies in Cambridge, MA, USA. He's worked on distributed systems and middleware systems for over 20 years, including distributed object systems, service-oriented systems, and RESTful web services


How Best to Blend a Domain-Specific Language into a Host Language?

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.



Philip Wadler

Philip Wadler has contributed to the designs of Haskell, Java, and XQuery, and is a co-author of XQuery from the Experts (Addison Wesley, 2004) and Generics and Collections in Java (O'Reilly, 2006).


A Little Graph Theory for the Busy Developer

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.



Jim Webber

Dr. Jim Webber is Chief Scientist with Neo Technology, the company behind the popular open source graph database Neo4j, where he works on R&D for highly scalable graph databases and writes open source software. His proven passion for microservices ecosystems and REST translate into highly engaging workshops that foster collaboration and discussion.


Industrial Experiences Transitioning to Functional Programming

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.



Jed Wesley-Smith

Director of Engineering
Simple Machines


Web Performance – The Past the Present and the Future

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)?



Jared Wyles

Sr. Computer Scientist
Adobe Systems


SkillsCasts

Hold tight, skillscasts coming soon!

 

Other Years