Session submission is now open. If you would like to speak at DDD East Anglia, please submit a session.

Developer! Developer! Developer! East Anglia

DDD East Anglia

Saturday 21 September 2019
Cambridge, UK


Session submission is now open. If you would like to speak at DDD East Anglia, please submit a session.

Session submission guidance

We are aiming to put together a diverse programme, so we welcome submissions from any member of the UK developer community on anything relevant to modern developers. To uphold the principles of DDD events, we will favour new and local speakers over established speakers or speakers from a more remote geographical location. To encourage first-time speakers, we have put together a list of resources to help with session submission.

About the Audience

DDD audiences are interested in hearing about what you have learned about the topic that you are speaking on, being introduced to a new topics, ideas, technology, or hearing about your experiences with a project you have been working on.


Our sessions are 30 or 60 minutes long and are usually single-speaker talks on a specific subject, although some have featured multiple speakers. Technical sessions, particularly those featuring hardware elements (e.g. Raspberry Pi), work well when demos and code samples are included. That said, we also welcome sessions that are based around a new format not yet presented at a DDD event.

Topics that have previously been covered include unit testing, test-driven development, NoSQL databases, JavaScript, Docker, functional C#, software architecture, F#, plus many more. "Softer" topics such as best practices, agile software development, and taking your side project to a prime-time business have also been presented. We always welcome session submissions on new topics.

Review process

Sessions are voted on by prospective attendees before registration opens. The organisers of DDD events use the results of the voting to determine which sessions are most popular and therefore make the best event for our attendees.

The sessions that have currently been submitted are listed below.

.Net Configuration Is Easy, Right?

Let's face it, we've all done it at some point. You have a value in your code that you don't want to hard code as it will vary in different environments or needs to change in a runtime environment, so you want to make it configurable in a file. That's where the fun begins.

In the.NET Framework, you usually create an XML configuration file and reference it using some static methods. Or maybe you use the designer in Visual Studio to do the work for you? In .NET Core, you are given a JSON file by default and access it through the IConfiguration interface. Job done ...or so you think.

  • How do you code the keys to access the values?
  • How do you unit test it and what if you need to test different values?
  • What if you want to store values other than primitive types?
  • What if you want to have secure passwords, but don't want them in your source control?
  • What if you don't want to use json files ... or come to that, don't want to use files at all?
  • What if you want to change values in a Docker container

.. and the questions go on and on.

In this talk, we start with a brief overview of the history of configuration in .NET Framework and how Microsoft handed developers a loaded gun to shoot themselves in the foot. Moving on to .NET Core, things are much better, but there are still some gotchas.

Lastly, the talk goes on to deal with the questions raised above with a "SOLID" based approach that makes configuration not only fully testable, but adds enhancements to handle encrypted configuration values (because you're not storing passwords as clear text in source control are you?) and validation of the configuration data before it hits your code.

The talk aims to help new developers avoid the pitfalls that others have fallen down and give experienced developers some food for thought as to how they might want to reconsider how they do configuration.

2 Fast 2 Furious - designing for speed, concurrency, and correctness

With the multitude of isolation levels, concurrency models, and specialist technologies available in SQL Server, it is no surprise that transaction throughput and correctness can be directly correlated to the ability and knowledge of the person that wrote the code.

In this session, we will reveal how SQL Server concurrency and correctness often goes wrong, how we can avoid this, and how we can use our knowledge to design and develop for optimal server throughput for our applications and processes using tips and tricks gained from real-world scenarios.

We will cover SQL Server’s traditional locking model, In-Memory OLTP, Columnstore, Delayed Durability, and many other technologies and techniques you can use to make your transactions more robust.

A Balanced Diet of Documentation

Documentation isn’t always straightforward. Tutorials, QuickStarts, References. It can be difficult to know where to start. In this talk, we will look at the different types of documentation and how to strategically balance them for maximum impact.

A developers guide to Infrastructure as Code with Terraform

As we move resources into the cloud, and we look to implement a more DevOps focussed approach, developers are having to learn more and more about deploying Infrastructure. In particular, Infrastructure as Code.

In this session, we will explore the concept of Infrastructure as Code (IaC0 and what it means for developers. We will dive into using Terraform, one of the most popular and versatile IaC tools and use this to deploy some infrastructure into the cloud. We will look at how we define deployments, how we work with parameters, variables and secrets, how we manage the infrastructure life cycle and much more. Most importantly, we will look at how we bring together application and infrastructure development in a world where developers need to be aware of all of this.

This is a demo-heavy session looking at real-world examples of IaC deployments, using real-world tools and techniques.

A Tale of GraphQL

There are a number of architectural styles and syntaxes for APIs. Since almost two decades ago, REST API has been the de facto standard and it has been helping companies build their APIs and deliver products that their customers love. However, some companies found that they need another approach to solve some problems they face with their APIs.

This talk tells the story of why GraphQL was invented and what problems it contributed in solving. There’s also another story of how GraphQL was used by another company to solve a completely different problem by incorporating it into different levels of architectural stacks.

Affective Computing – Bringing humans and machines closer through emotions

If we want computers to be intelligent and able to interact with us we need to ensure that they can recognize, understand and express emotions. This is the basic assumption of Affective Computing.

First an introduction to the field will be described starting with established findings from psychology on how we best can measure emotions. Technology enablers that has made Affective Computing a hot topic will be highlighted as well as examples of API and services that we can use today.

The second part will cover application scenarios such as retail, medical, education and social. The presentation concludes with some recommendations on how Affective Computing affects us as developers going forward.

An introduction into GraphQL

Between 2010 and 2014 the tech industry had a huge adoption of Mobile Technology. Companies all over the world were investing heavily within this mobile industry.

During this time Facebook invested in delivering HTML5 experiences on mobile to customers and later hugely regretted it. Mark Zuckerberg even says that this is the biggest mistake the company has ever made. Facebook then went onto creating in house mobile development teams, but soon realised that the API's that were designed for the web could not scale with their new mobile platform.

On February 29th 2012 an internal idea was born at Facebook called "SuperGraph". "SuperGraph" was designed to help development teams move faster and increase the flexibility of their current APIs. A small team got together and released its first version into production 4 months later.

In 2015 Facebook open sourced this new technology as "GraphQL".

Since 2015 we have seen many companies adopt GraphQL and a huge investment from the open source community to support GraphQL on many different programming languages (C#, Clojure, Go, PHP, JavaScript, Scala, Ruby, Erlang).

In this talk, we will take a dive into GraphQL and try to understand why so many companies are adopting it. We will look at what problems it is trying to solve, the fundamentals of the language and how you can get started today.

Walking away from this talk I'm confident that you will gain an understanding of GraphQL and hopefully inspire you to continue to explore GraphQL in the future.

An Introduction To Domain-Driven Design

This talk is an introduction to Domain-Driven Design which provides a formalized approach to developing complex, scalable and robust software.

We'll take a tour of Domain-Driven Design (DDD) to understand what it is and how it can help develop complex software by aligning software development closely with the business domain. We'll look at Strategic Domain-Driven Design which helps us to build a useful domain model upon which we'll base our software, then we'll look at Tactical Domain-Driven Design which we use to turn the model into software and helps us achieve our goals.

Authentication for Serverless

Authentication is a challenge at the best of times and running "serverless" adds some new challenges.

In this session, I will share with you how to authenticate your users and keep your application secure. I will illustrate the threats to your system and how to avoid pitfalls. You'll explore some of the options for Azure Functions and considerations for when they might be used.

How do you choose between home-grown, open-source, Azure or third-party authentication systems? You'll learn various ways to implement Authentication for Serverless and how you choose between them.

Azure Cosmos DB for Dummies

Azure Cosmos DB is Microsoft’s premier NoSQL Cloud-based globally distributed database offering, providing scalable performance and resiliency, customizable consistency guarantees, multiple data models APIs, and comprehensive service level agreements.

In this session, we will explain how to get started in Cosmos DB and demonstrate simple administrative and development operations so you can learn how to go from zero to hero in no time. We will cover many fundamental topics which include: * Cosmos DB APIs * Accounts, Databases, and Containers * Geo-Replication * Partitioning and indexing * Consistency and throughput

Azure Cosmos DB is not just the future for Online-Transaction Processing, it is the present!

Being transactional in 2019 - what does this actually mean?

When I was young and took my CS classes I learned about ACID and it seemed sound and reasonable. Then I went to work and learned that it could mean different things (especially isolation…) for different database vendors… Around 2009 I’ve heard about CAP theorem - that was also sound and quite reasonable in the brave, new distributed world. And then one after another - NoSQL vendors started to claim they’ve beaten CAP theorem (* as they understand it of course…) And recently it got even more complex - stream processing engine have their notion of transactions - atomicity, isolation and so on.

In this talk I will try to make something out of this mess - we’ll look at some of definitions and try to figure out which use case require particular kind of isolation or transactionality. Of course some of it will be based on my own experience - including quite a lot of blood, sweat and tears ;)

Better types - how to program safely from one checkpoint to another

I will present algebraic data types idea on F# example with C# comparison. I will try to explain: why as functional programmers you won’t fall in the trap of breaking Liskov substitution principle? How to transform your problem into a nice language using algebraic data types.

Have you ever consider why functional programming makes things simpler? We tend to break problems to smaller chunks, but never think how to combine them back into the working mechanism. And this is what functional programming is about and give us this magic glue element. In this talk, I will focus on types. I will present:

  • what type is from a functional programming perspective,
  • show the difference between abstract data types and algebraic data types,
  • properties of algebraic data types and how to use them,
  • model some examples using these types and try to show how using simple concepts can model complex problems.

Beyond HTTP in ASP.NET Core 3.0 with gRPC

In this session, I'll introduce gRPC, a modern high-performance RPC framework for inter-service communication. We'll look at how gRPC stacks up against existing REST-based communication and explore the benefits this technology has to offer. gRPC uses HTTP/2 as its transport protocol and ProtoBuf encoded content for efficient, fast communication.

You'll see C# examples of how to build client and server gRPC components using ASP.NET Core 3.0, using the blazingly fast Kestrel web server. You'll learn how to define your proto3 service definition (contract) and integrate with MSBuild tooling to code gen the server and client components you'll need. You'll be amazed at how quickly a service can be created with little effort or boilerplate code required. You'll also see how additional clients can easily be generated for other languages such as Node.js to make connecting polyglot systems a breeze.

It's a great time to begin taking notice of gRPC as a worthy contender to take over from REST for inter-service communication in microservice-based environments. It's time we started to let service talk their own language!

Building your first dashboard with Azure PowerBI Embedded

Users love dashboards… Dashboards give them that warm fuzzy feeling that they can see into your software and watch it working perfectly… And dashboards give you the same insight into what's actually going on.

Microsoft's new Azure PowerBI Embedded product lets you capture data, analyse it and present it on dashboards that live within your application.

In this session, I'll take an existing application, instrument it, pipe the data into Azure and demonstrate just how easy it is to create a rich dashboard to monitor the application's performance.

Clouds, Microservices, and the brittleness of architecture

Why your cloud architecture might kill your software.

In this talk, we discuss what cloud native really means for your software - and more specifically why ignorant use of excellent technology can actually damage your application, rather than help it. We'll discuss some excellent features of the Azure platform, but also dive deep into the things that will definitely go wrong when you use them thoughtlessly - along with exploring some battle tested, cloud native patterns for avoiding certain disaster.

Code the Cloud - Powering up our infrastructure with Typescript & Pulumi

Modern infrastructure is often managed using error prone and specialist domain languages which often leads our engineers to specialise and not apply our core skills.

Let's power up our infrastructure using Typescript and Pulumi. We can write our infrastructure using a language we already know, with tools we already use and version it all along with our code.

I'll show examples and demos using Typescript to manage serverless APIs, docker containers and Kubernetes clusters

Code the future, now

We know how to write code to do something now. What about code to do something tomorrow, or next year? Sometimes we use batch jobs. But as business grows, our "overnight" batch job starts finishing around lunch time. As we expand to new regions, we realise there is no "night". And it's only a matter of time before we make a change and break a batch job we forgot existed. What if tomorrow's code could live in the same place as today's code? What if it all looked the same? What if we could scale it all the same way?

Join me and discover how to embrace the future in the code we write now. Learn how to capture requirements as first class business logic, and avoid relegating them as second class citizens of the batch job world. Take a deep dive into techniques which combine off the shelf products with fundamental computer science.

Where we're going... we don't need batch jobs.

Databases on Kubernetes: Why you should care

With the rise of Kubernetes StatefullSets and CRDs, we started thinking about running databases on it. But why should I do that in the first place? How hard is it? Which are the challenges? Is it production already? All those questions will be answered during a live demo where we will deploy a database, deploy an operator, fail nodes, scale up and down with nearly no manual intervention.

Dependent types, generic programming - why would you actually need it?

When you look at functional programming conferences agenda you’ll see quite a few talks on “esoteric” stuff like dependent types or various kinds of generic programming. More often than not they end up in advanced scala or haskell, debating Martin-Löf type theories or event category theory. But why…? Why does reasonable developer would like to embark on such a journey?

This is not advanced FP conference so I’d like to talk about it from a bit different perspective - from perspective of 'regular' Java developer.

I’ll try to show how we can meet these and similar concepts in “normal” world - of course in “regular” Java it’s usually not possible to do “real” dependent types, but we hopefully discover some intuitions why such concept is useful. The talk will be partially based on my experience - currently I’m working on a tool which helps users create “programs” without “code”. Quite a few times familiarity with generic programming helped me with design.

Developer, develop yourself!

Not all of you have very modern technologies in you project. In fact, sometimes you have very old language and/or libraries. Not all of you have mythical 20% spare time for experimenting. Not all of you have open-minded management that allows you to gather and have some internal workshops or spare time on research.

But there are various ways to learn new stuff even if you don’t have time or money available at your work or in your pocket.

I invite you to a story about things you can do as a developer to improve yourself and/or your team. It will be about workshops, hackathons, code review, writing blogs, doing open source, speaking at meetups and conferences and lot more. I did all of that and I want to share my wide experience with lots of advice how to do it right.

Some of them are expensive but most is quite cheap.

The purpose of that is to learn new things, experiment with technologies, advance and have fun. Without that we could have only our day to day tasks which can be boring or frustrating. I will share with you my wide experience with lots of advice how to do it right.

Developing with .NET on AWS

In this demonstration-heavy session, we illustrate our latest techniques, tools, and libraries for developing a .NET application on AWS. From within Visual Studio, we will look at three different ways to run your .NET applications and show you how to integrate with various AWS services, including Logging, Managed SQL Server and Machine Learning Models. We will cover ways to build and run serverless and containerised applications as well as show you how you can move legacy.net apps to the cloud.

End-to-End Reactive with Spring 5 and NoSQL

I/O is the source of the majority of blocking operations in most systems, and with blocked threads, the overall throughput of your application is compromised. Unfortunately, threads are expensive on the JVM and in other platforms, and even if they weren’t we would still need to deal with faulty networks and slow requests.

Spring Framework 5 introduces support for reactive programming with Spring Webflux, which is really awesome, but wait… aren’t we forgetting anything? What about databases? Database access should be reactive too!

In this session, we will get an overview of R2DBC and live code an end-to-end reactive application using Spring 5 and Couchbase Spring Data, which allows you to dive down to the native reactive interfaces when you need to optimize until the last mile.

Falling down holes for beginners - Getting started in open source

As engineers we often worry that we're imposters and our successes are freak accidents. Many of us don't feel we can contribute to open source as we feel we have nothing to provide to the wider community or that our skills aren't up to par.

I felt the same until I ended up being the maintainer of a project and falling down the rabbit hole, improving my skills in the process and learning a lot.

Using myself as an example I'll explain how I got involved, the mistakes that I made to help you avoid and some resources you can use to get you started.

Fancy Bears are not your problem - real world appsec

Fancy Bear, Stone Panda, Lazarus, Charming Kitten and Equation Group are Advanced Persistent Threat groups. Woah, sounds scary!

What are the threats from these groups? Do we really need to worry about them or do they just make attention grabbing news stories?

In this talk, we will explore why APT groups might not be the thing that application developers need to worry about and the things that should get attention in application security. You'll see some tools and techniques that help find the important problems to work on and the ways to resolve those problems. This is real world appsec.

Fermi Problems - Why Devs Hate Them But Data Scientists Love Them

You all know what a Fermi Problem is, even if - as a dev - you didn't know that was what they are called. They are those annoying questions you get asked at interview, you know, the ones that go "So, can you tell me how many filling stations there are in the UK?". The ones where you think, "What a pointless question". Well, the fact is - to a data scientist - they are extremely important in predictive analytics and in this session, we'll lift the lid on Fermi Problems and I'll show you exactly where, and why, they are useful.

Finding your service boundaries - a practical guide

We know it's useful to split up complex systems. We've seen the benefits of modular deployment of microservices. Dealing with only one piece of code at a time eases our cognitive load. But how do we know where to draw the service boundaries? In complex business domains, it's often difficult to know where to start. When we get our boundaries wrong, the clocks starts ticking. Before long, we hear ourselves say "it would be easier to re-write it".

Join Adam for practical advice on discovering the hidden boundaries in your systems. Help tease out the natural separation of concerns in a sample business domain. During 20 years of developing complex systems, Adam has had plenty of time to get things wrong. Learn to avoid the common pitfalls that can lead us down the path to "the big re-write".

FizzBuzz - a minute to learn, a lifetime to master

If you've heard of FizzBuzz, chances are that you'll think everyone has. Yet, over several years of interviewing developers, I've been surprised by how many people have never heard of this classic programming problem. So, if you've never heard of FizzBuzz, I can assure you you're not alone.

Though it's often the source of scorn and derision, I'm unashamed to by a fan of FizzBuzz as an interviewing tool. After dozens of interviews in two languages with candidates at a range of levels, I...

  • Have seen all the basic approaches
  • Know the usual places someone will mess up
  • Have an arsenal of stretch goals for those who've mastered the basics

And since I've kept all the attempts by candidates in my interviews, I can start to quantify this stuff too.

In this talk, I'll start by giving an overview of the task and how we use it as a foundation for our technical interviewing. I'll then move on to the common approaches and pitfalls, before demonstrating some of the ways we can turn it up to 11. Throughout this talk, I'll explain why each of these things makes FizzBuzz an invaluably rich tool for the interviewer.

Think you know FizzBuzz? Think again.

From Ancient Greeks to Modern Geeks

There is a philosophical conundrum that has existed since antiquity, and problem that continues to be relevant to this day - especially to those of us that code for a living:

How many rocks do you need to make a pile?

We could put this all sort of other ways - how many hairs can someone have before you stop considering them bald? How many years old is someone before they start being old? How many Doctor Who stories have there been? None of these things have definite answers, just a vague sense of when an answer is definitely true, definitely wrong, and a whole load of fuzzy possibilities between.

Computers like strictly defined, easy to predict answer - "A pile of rocks is 10 rocks", but this doesn't help us to meet business requirements.

Philosophers, mathematicians and scientists have wrestled with this problem throughout the millennia, and all sorts of answers have been suggested. How can we use their findings in our day-to-day lives as developers?

What code patterns exist to allow us to give definite answers to fuzzy, vague questions?

We'll do our best to answer all of these questions - and more - and all with some nice, friendly C# code samples.

Full-Text Search - Tips & Tricks

The real challenge in search is not how to pick the best search engine framework or how to find a match, but how to bring the most relevant results first. Modern search engines have been heavily using machine learning to understand what is relevant for their users, but this approach requires tons of time and effort.

In this talk, we will show how to implement from scratch a clever search for your application using just a little bit of planning and standard features provided by any search engine framework: boosting, analyzers, tokenizers, fuzziness, facets, penalties, etc. We will also review some core concepts and show how to fix common relevancy problems.

Getting the first PR into .NET and other tales from an OSS contributor

The world of open source software has never been more exciting than it is right now. Communities spanning all platforms are thriving and more inclusive than ever. Even Microsoft have transformed their strategy, becoming the "number one" GitHub organisation. Why the big change? What's wrong with the "old" way of doing things?

In November 2014, I became the first community member to have a pull request accepted for .NET Core. With my 15 minutes of fame now over, I'd like to reflect on the journey that took me there. How did 'that Czechoslovakian guy' go from a curious OSS onlooker to a passionate OSS advocate?

We'll discover what OSS is, why it works and how easy it is to get involved. OSS is not only about coding and there are plenty of other ways to contribute. Even if you're not a coder, this talk is still for you.

Hacking C#: Development for the Truly Lazy

I don't know about you, but I'm a lazy developer. What do I mean by lazy? I don't mean I don't want to do my work - far from it - I mean that I hate to write out a great deal of code to get the job done. I want to accomplish my goals with as little effort as possible.

One of my pet hates is writing enhancements that involve copying and pasting blocks of code, changing a variable name, then leaving everything else the same. I hate having to consider each and every possible null reference exception, and adding in a whole ton of boilerplate to handle it. I hate having to spent ages jumping back and forth in a legacy codebase, trying to understand what it actually does!

What's the alternative? In this talk, I'll demonstrate a way of working that avoids all this unneccesary work, and gives you more time to do something more productive.

We'll look at:

  • Functional Programming - what benefits does this increasingly popular paradigm bring us to cut down coding effort

  • Linq & Generics - These have been a part of C# for a long time now, and are some of the most powerful features available in the language, but hardly anyone seems to be using them effectively

  • MetaProgramming - break open C# and take it to the next level with code that describes how to generate code

Our goal is to write code in as few lines as possible that provides the greatest amount of impact. We also want code that's readable, and easily maintainable. We want to think smart, and think...Lazy.

How React.js has transformed comparison at comparethemarket.com

Want to use React at your company but feel too invested in old tech? Then fear not this talk is for you.

We take a look at how React has transformed the way comparethemarket.com does comparison. Serving millions of customers a year, we explore why it’s not too late to start re-thinking the wheel.

During this talk we are going to cover how we completely reinvented our tech stack to harness the power of React. How we use it to allow our teams to develop at scale and with confidence. While also giving you a heads up on what you should be looking out for and how you can best prepare your teams for success.

So come along, sit back and let’s discuss how React has changed the landscape, one component at a time...

Here’s a few reviews from previous audience members: **

“A talk not to be missed..." (Dan Abramov)

“Simply spellbinding” (Rory Cellan-Jones - BBC technology correspondent)

“Another sensational talk, leaves you wanting to go away and write more components” (Kyle Matthews - Founder of Gatsby.js)

** I have 100% just made all these up, please don’t @ me. 💃

How to Hack an Election

Think your democracy is safe? Better think again. In this session I'll demonstrate the techniques that the 'black hat data scientists' use to get the result they want from any election or referenda. In this entertaining talk, I'll demonstrate techniques, both at the macro level - how to attack an election systemically - and at the micro level - how I can manipulate individuals to do exactly as I want them to do.

*Fully updated since the talk was given at NDC Oslo 2019.

How to kill a bug without touching it

Many times when debugging the F10 and F11 keys get worked overtime, and maybe the occasional breakpoint. However Visual Studio has many functions to help with debugging. In this talk I will go through the debugging features from basic breakpoints to thread and processes windows, showing how these can be used to speed up the beginning, by getting quickly to the problem code. My talk will include:-

  • Breaking on exceptions

  • Breakpoints and tracepoints

  • Debugging multithread/parallel applications

  • Watch window

  • Customising debugging information

  • Symbol Server

How to use Cognitive Services to make a multi-lingual chat bot

Chatbots are commonly used in a wide range of user scenarios such as ordering pizzas, product suggestions, schedule meetings or customer support. But how can we as developers make our own chatbot?

In this session I will demonstrate how you can make a chatbot by using the Microsoft Bot Framework together with LUIS (Language Understanding Intelligent Services). The chatbot will be multi-lingual meaning it will adapt in real-time according to the user’s language (i.e. switching from English->Spanish->Norwegian).

Finally we will integrate our chatbot in a web application and demonstrate how we can use this in a realistic scenario.

This presentation will be code centric with the majority of time spent in Visual Studio and the Cognitive Services portal.

I was a frog being boiled slowly by Cosmos DB. (I will not be a frog again.)

This talk is not about Cosmos DB. Well, actually, maybe it is a little bit. But it's really a case study of tricky problem-solving.

Come on an adventure with me, as I recount our efforts to tame an out-of-control database. Then, stroke your chin with me (I'll stroke my own) as I reflect on what we should have done differently, the factors that lead us down the paths we explored, and the lessons we can generalise from the experience.

Our Cosmos DB instance was struggling to keep up with our fast-growing user-base. Despite the rapid scaling, it should really have coped. "What's going on?" we asked each other. Over the course of several weeks, we tried several approaches, but the problem got steadily worse. Some of the things we tried were quite interesting, but they had varying levels of success. The eventual solution was infuriatingly simple, so why did it take us so long to work it out?

This talk will cover some real-world techniques for tuning and optimising Cosmos DB but will focus on the process of solving complicated operational problems with new (i.e. "under-tooled") technologies.

In Retrospect - Making Retros Great Again

Many of us are used to working in Agile teams. But as time goes on, do you feel like retrospectives have become boring, uninspiring and less effective? Does it seem like the team are just going through the motions, but the process is failing you?

This session will take a look into the surprising cross-disciplinary history behind retrospectives, leaving you with a deep understanding of why we perform them and how feedback is the "engine" of Agile development. You'll learn how to engage your team in fun retrospectives and you'll leave with a renewed sense of focus to make Agile work for your team.

IoT in your Home? What's the worst that could happen?

So, you've heard of the amazing things you can do with Internet of Things devices, and can't live without an internet-enabled toaster that toasts today's weather forecast on one side and the news headlines on the other. Good for you! But...like Jeff Goldlum said in Jurassic Park, could it be we were too busy asking whether we could, to consider whether or not we should!

What are the consequences of allowing an IoT device unfettered access to your home network? Would you be surprised to hear that they could extend from stealing the data in your laptop, all the way to threatening the very infrastructure of the internet itself! This is no conspiracy theory either - it has already happened, and most likely will again.

Naturally, we don't want to have to abandon our IoT toaster out of sheer panic, we want to know what we can do to still have our weather-patterned bread and be safe.

This talk will look into the threats that exist our there to you - the home IoT user, and what steps you can do to mitigate them. We'll be covering simple steps that nearly anyone can implement, as well as briefly looking at some of the more advanced steps for experts.

It's People! Code is made out of people!

It doesn't matter what language you use, what platform you code on, or what editor you prefer; there's one underlying thread common to all code: people. It's also the hardest part of coding. Unless you're a team of one, writing code only you are going to use, people are always going to enter into the equation. So lets bypass the fancy algorithms, forget about the methodologies, and look at how we deal with the people aspect of code. The people we work with. The people we're coding for. The people who were here before us. And the people that will come after us. And maybe, just maybe, we'll come out of it better developers.

Landing on the Desktop with Electron

As web developers, it can be easy to feel handcuffed to the browser. Thankfully, Electron enables you to use HTML, CSS and JavaScript to create cross platform desktop applications. By the end of this talk, you’ll have a basic understanding of how to set up your first desktop app.

Loggers: regain control over your application

Good logging practise is not very common. People mostly focus on writing business rules, testable code and great architecture designs. But they forget about keeping control over the application and proper logging. Especially when something blows out on production. The thing is to have good logging habits since very first line of the program. Not when it’s too late and one has to do “post mortem” investigation what went wrong. In my talk I will tell how to use loggers wisely, what to focus on, how to log efficiently and safely for you application, how to cope with masses of information, even in distributed environment.

Please join my presentation.

Machine learning in the browser with TensorFlow.js

In order to start out with machine learning you typically would need to learn Python, Tensorflow, Jupyter Notebook etc. But what if we could run our machine learning algos straight in the browser. This can be done through Tensorflow.js. In this session you will get an introduction so that you can use it in your own projects.

Make Your Tools Work

Software development is challenging, and cognitive overload is an enemy of productivity. We [software developers] probably spend more time in our IDE than we'd like to admit. We have the skills and ability to make our own lives better through technology, so why aren't we spending more time making our tools work better for us? In this session I'll talk about some of the ways we're making our own lives better through better tooling.

NoSQL with Couchbase

Today's mission-critical applications demand support for millions of interactions with end-users. Traditional databases were built for thousands.

Couchbase Server is an open source, distributed, NoSQL document-oriented database. It exposes a fast key-value store with managed cache for sub-millisecond data operations, purpose-built indexers for fast queries and a powerful query engine for executing SQL-like queries.

In this talk, we develop a small microservice using a very productive combination: Couchbase, Spring Boot and Spring Data. We also will deploy both your application and database on Kubernetes, to show how you can build truly elastic microservices.

Offline web apps don't exist anymore!

Progressive Web Apps (PWAs) enhance web applications and make them ready for the future. In this session we dive into the world of PWAs, looking at different caching strategies to boost performances and to increase users re-engagement. We will then bring those features to a next level with Cloud Firestore, showing how it is possible to provide our users a "never offline" experience by combining those technologies.

Patterns For Resilient Architecture

We have traditionally built robust software systems by trying to avoid mistakes and by dodging failures when they occur in production or by testing parts of the system in isolation from one another. Modern methods and techniques take a very different approach based on resiliency, which promotes embracing failure instead of trying to avoid it. Resilient architectures enhance observability, leverage well-known patterns such as graceful degradation, timeouts and circuit breakers and embrace chaos engineering, a discipline that promotes breaking things on purpose in order to learn how to build more resilient systems. In this session, will review the most useful patterns for building resilient software systems and I will introduce chaos engineering methodology and especially show the audience how they can benefit from breaking things on purpose.

Positive Outsourcing: The culture of great partnerships

Are you considering outsourcing functions within your business and are concerned about the impact this might have on your organisation? Or perhaps you are already working with a software development company and facing a number of challenges?

Let’s be honest, in some organisations “Outsourcing” has become a dirty word, synonymous with internal conflict, poor quality and boundless communication challenges.

But does it have to be that way? In my talk I will outline how comparethemarket.com has built an award-winning partnership with Godel Technologies in under 2 years. From culture to process, I will take you through our journey. Covering how we approached the partnership, how we managed the day to day, some of the challenges we faced along the way and how we addressed them.

Power BI for absolute beginners

Power BI is an environment consisting of several reporting tools and platforms each utilizing different languages and capabilities for data modeling, data insights and report sharing. If you are new to the world of Power BI, this can all get a little overwhelming and leave you feeling confused and frustrated.

This session is designed to get you started writing beautiful reports and dashboards as quickly as possible. We will first lay the groundwork explaining how the whole Power BI stack hangs together, for both on-premises and cloud services and tools, and how you can use them to share your reports.

Next, we will focus specifically on how you utilize those reporting tools to create beautiful reports, dashboards, and paginated reports.

By the end of this session, you will be comfortable connecting to remote data sources, creating your data model, and designing and publishing your first Power BI reports and dashboards.

Programming with yarn

Crochet and other yarn crafts can be viewed as a form of “programming in the wild”. Without realising it, crocheters interpret their own patterns, thus becoming “computers”. This talk explores the analogies between a crafty — analogue — discipline and what we, as developers, know of programming.

It covers several notions that can be illustrated with crochet, such as: crochet patterns as programming instructions, language versioning, humans as computers/compilers, debugging, multithreading (quite literally). It also ties the discipline back to the origins of computing, and the inspiration behind Babbage’s Analytical Engine. Finally, we look at how crafts and programming can be intertwined, and create new ways to make analog and digital work together.

This talk is designed for a varied audience (new to programming or experienced), as it offers a new angle on the discipline and is language agnostic.

Property-based testing in Rust

Do you love well-tested code but hate thinking of test cases? Do you often forget important cases when writing the code, and forget those same cases when writing the tests? Me too! We have so much in common. I've found that property-based testing helps with that problem by making the computer do the boring work of finding test cases. In this session, you'll learn enough about property-based testing to apply it to any language, and you'll see examples of property-based testing of Rust code.

Rapid API Development in Go

The Go programming language is a statically typed, compiled programming language designed at Google that was released in 2009. It grew quickly in popularity - holding a top 5 position in the most loved programming languages in the Stack Overflow developer survey for 5 consecutive years, and in 2018 was the fastest growing language on GitHub.

Much of Go's popularity can easily be attributed to it's clear and concise syntax, simple concurrency model, strong built-in tooling, and its ability to be easily compiled into a single statically linked binary. However, to me Go's greatest strength is its robust, "batteries included" standard library, which allows developers to rapidly build production ready applications with little to no external dependencies.

In this talk I will provide a brief overview of the Go programming language, and demonstrate how Go can be utilised to rapidly build production ready APIs with just the standard library - HTTP(S) server and all. Finally I will provide a brief demo of a simple API workflow, and talk about some small libraries and tools that can be used to improve the development process and general quality of life.

Sharing (Knowledge) Is Caring

  • Are you transferring knowledge well?
  • Are you being understood?
  • How are you supposed to know?
  • What can you do to make yourself better understood?
  • What should you stop doing?
  • Have you even thought about how well you are putting things across?

Skills for sharing knowledge are something that you are expected to pick up as you progress in your career, without much or any formal training. I want to share knowledge with you from my experience as a teacher and as a programmer. I will answer these and other questions around this important, but often overlooked part of being a software engineer.

I will help you make yourself understood. I will reduce that awkwardness when you can't make yourself understood, and just don't know what else to do.

I hope this will be an informative and entertaining interactive talk.

Sharing code with 200 Engineers

React helps encapsulate Front End tech into components, but how do you go about sharing those components across your organisation - for everyone to use, as easily as they would open-source components? In this talk I’m going to speak about how we build and share our React component library internally at ComparetheMarket, the tools we use to assist us, and how we make it worth the effort.

Sight Reading Code

A cerebral dive into why code is like music, and literature - a primer to the text and the subtext in software design. You don't write code for a living - you read it.

We'll take a look at the different ways you can interpret codebases to discover authorial intent in software. We'll look at what I learn about you from the style of your programming. We'll look at the breadcrumbs to meaning that exist in the odd and unexpected corners of a codebase.

Hopefully we'll learn what makes code subjectively and objectively beautiful, and useful.

Solving microservices challenges on the Kubernetes platform

Developing microservices based applications is a hot trend in our industry. However the journey to microservices is fraught with problems, by trying to solve one problem we often introduce a set of new ones.

This talk introduces a "journey" to microservices and highlights some new problems that are created by adopting such an architecture.

We then step through how we can leverage cloud native technologies such as Kubernetes and service meshes such as Istio to try and address some of these new problems.

This talk along with demos will cover many topics in an area which is rapidly evolving however we'll try and focus on the fundamental problems, and demonstrate tools that can help make the experience better or simply easier to manage.

Attendees will learn: Why microservices introduce many new challenges. How cloud native technologies (such as Kubernetes, Azure Dev Spaces, Istio) can try and help address these challenges. Some general guidance on microservices architecture.

Some knowledge of microservices, containers and Kubernetes is useful but not essential we'll cover the basic topics

Solving the Travelling Surveyor problem in .Net using Google OR Tools

The "Travelling Salesman" problem is a computational classic - but firmly grounded in the real world.

In this session I'll discuss how at REDACTED we used Google's Open-Source Optimisation & Routing (OR) Tools to generate recommended routes for hundreds of surveyors and thousands of jobs on a daily basis for one of the largest firms in the country.

We'll cover the basics of the problem, and some of the classic approaches before moving on to how to use the tools Google OR Tools library. We'll look at some pitfalls and limitations - as well as how we created a fluent API for describing general case routing problems to pass to the Google OR Tools library.

Sports Betting: How I made £500 During Royal Ascot And What That Can Teach You About ML

By now most of us have a rough idea of what ML is all about, right? Good, but what do we do when ML, alone, just doesn't cut it, when there's either too many variables, or their starting values are non deterministic? Well that's a question we'll answer in this talk - we'll also have some fun as we use what we learn to try to predict the winner of a horse race run during the talk.

*Fully updated since the last time this talk was delivered.

Storage Revolution: The latest and greatest NoSQL features for highly scalable applications

NoSQL is a fertile environment where new theories in distributed systems can grow and be heavily tested. Some of those theories end up being implemented in the most popular relational/non-relational databases. In this session, we will talk about the greatest features launched in the last 2 years, the current state of the art technology and what is coming next.

Databases were historically the biggest bottleneck of most applications, but with new software architectures and the rise of the so-called NoSQL databases, the scenario has completely changed in the last 20 years.

Modern theories in distributed-systems have solved issues with scalability, performance, availability, consistency, and data distribution and now we are on the edge of transactions, analytics, and self-management solutions.

In this session, we will talk about the vision of what is coming in the next few years and walk through some of the current key theories and architectures. talk about advantages, drawbacks and best use cases, so you can properly evaluate what is the best storage type for your next projects or how you can improve your current ones.

The cloudmakers

Compute has been evolving into serverless and orchestrated containers nowadays. Looking back almost two decades ago, the big jump from bare metal to cloud computing was done by an unlikely player and took the world by surprise.

Why and how was it done? Who were the brains behind the breakthrough? What were the impacts in software and product development and deployment?

Let’s look into the journeys of two big cloud providers and how they change compute world into what we know it today.

The History of AI - what can we learn from the past?

Nowadays AI is all the hype, but what many might not know is that AI is an established discipline originating from a workshop in the 1950s. This talk will describe the historical milestones of AI from that workshop up until present days. In addition we will get an understanding of what the future of AI might have in store.

Initially we will investigate what happened at the workshop in the 1950s. Then we’ll be reviewing a number of areas where AI initially was put to use between 1950-1970. We’ll cover the AI winter in the coming decades.

In the second part of the talk we’ll cover applications and milestones from the 1990’s and onwards. Finally we’ll look into the crystal ball to see where AI will takes us in the future.

The Startup's Guide to the Corporate Galaxy

Managing a team in the corporate world has many known challenges: disengagement, lack of creativity and inspiration, and no focus on personal growth - all of which lead to poor performance.

For Gad Salner, a software engineer and manager with more than 10 years of experience in the Israeli startup scene, In addition to a lack of engagement, managing a recently formed team within WeWork Technology has come with other interesting challenges. As many companies experience when they go from being small startups to larger corporations, many employees tend to feel the growing pains. Some of these include losing aspects of the employee culture, shifting goals, making sense of the madness, and the fear of becoming a small fish in a big pond.

In this talk, we will learn how to create a winning engineering team by applying cultural, agile and functional aspects of the startup world.

The three elements every error message needs

Just as adversity and overcoming shared problems tests and strengthens friendships, so can errors become crucial to your software's relationship with its users. Users might feel let down or helpless in the face of bad error messages. But what makes a good error message? We'll look at the three things users want from an error message, some examples of what happens if you miss out one or more, and put them together to make users feel good about errors.

The Very First Computer Program

We all know that Ada Lovelace is credited as the first computer programmer. But what did she write? What did it do? And how does it work?

In this talk, we'll break down the very first program ever written to explain what it does and how it works. And then we can go on to simulate it within a JavaScript version of Babbage's analytical engine, rewriting it piece-by-piece until it looks like modern code, and thereby demonstrate what features of current languages we now all take for granted.

We'll finish up with a discussion on the controversy surrounding her involvement in computing, aiming to answer the question once and for all - "Was she really the first programmer?"

Things in PWA era!

In daily basis where billions of billion devices are connected to the internet, browsers can actually take control Things like lightbulbs, robots, printers, NFC tags, toys, drones, and many more Things via web standard APIs such as WebBluetooth, WebUSB, WebNFC, Shape Detection API and etc. How about connecting to IoT gateway which supports Wifi via BLE ?!

On the other hand, Progressive web apps open a new era to build web apps that work offline and resemble native apps. PWAs are installable too, therefore, your solution to controlling Things in the real world can be written once for web and reuse everywhere.

In this session, I am going through some of the web capabilities to connect devices into a progressive web app and demonstrate how the web, eventually, could go beyond the browsers.

TPL Dataflow - The Best Little Async Library You've Never Heard Of

From the docs:

The Task Parallel Library (TPL) provides dataflow components to help increase the robustness of concurrency-enabled applications.

What it actually does is give you the tools to create in-process async pipelines in a simple, structured manner.

And I'm betting that like me (until recently), this is a library you'll never even have heard of.

I'll cover the basics - Sources, Targets and Blocks - and how to link them together into useful asynchronous and parallel pipelines within your programs. We'll handle error conditions, cancellation and how to control the degree of parallelism - with samples that give you a bit more than "Hello World".

Turbocharged: Writing High-Performance C# and .NET Code

In this session, you'll learn how to write C# code which executes faster and allocates less. This session is packed with practical examples and demos of where the latest high-performance APIs and language features can be applied in your applications.

During this session, we'll apply types such as Span and Memory to efficiently process data and to parse strings. We'll examine System.IO.Pipelines, offering high-performance I/O and we'll utilise ArrayPool to help reduce GC allocations. In .NET Core 3.0, we have new high-performance JSON APIs which we'll also add to our arsenal. Microsoft has made fantastic performance gains to the .NET Core framework; now it's time to apply them to your code!

We'll begin by discussing when and why performance matters in your applications. You'll learn how to measure your code, and use a data-driven approach to focus your optimisations.

These features can seem complicated, unapproachable and difficult to apply. In this session, Steve introduces high-performance newcomers to the features, showing you how they work, where they can be applied and how to measure performance improvements in your code.

This talk is for developers, who like Steve, are ready to begin their journey towards writing faster .NET code, which allocates less.

Web Assembly and Blazor

During the last decades a growing trend has been to put more and more functionality into the client by using the latest and greatest JavaScript framework. But what if we could be using native code in the browser in order to run computations faster and potentially reuse code from the backend in the frontend.

Enter Web Assembly. Web assembly is a new web standard which enables you to run native code as part of your current JavaScript framework. This talk will give you a thorough understanding of what web assembly is and how you can use it in your project.

We will cover a practical example writing our web assembly using Rust. We will go through everything from writing your web assembly code to publish it as a npm package and finally use it in an existing web application.

Blazor is a new framework from Microsoft where developers can use C# to write a full web application without the need of learning a new JavaScript framework and related tools. Blazor builds upon Web Assembly and we will go through how Blazor can be used in order to build a full-fledged web application.

You're a failure (And so am I)

Some of the greatest innovations have come from failure. For every success we celebrate there are untold attempts, almosts, nice tries and utter failures that we don't hear about. Ask any entrepreneur how many times they tried before they succeeded and the chances are you'll be given a litany of ideas that were 'before their time', 'not ready for the market' or simply 'too disruptive'

But I have a hypotheses which is this. Our best learning comes from the failure, yet we spend miniscule amounts of time talking about these failures. If we want to improve as individuals and as teams we need to discuss failure more often.

In this session we'll explore failure, why we fear it, what happens when teams talk about it more and what you can do to celebrate failure

You're the Tech Lead - *you* fix it!

Over the last couple of years, I've presented 20 tricks and tips that I've found invaluable as a Tech Lead. But in this session, I want to turn things around and look at applying some of those to solving specific issues that are common within many software development teams.

I'll be taking lessons learned from the last 2 years of a major development project and using them to illustrate my points.

We'll look at managing your BAs and PMs and how to balance their need to understand exactly how long everything takes versus your team's need to not be over-pressured by artificial deadlines.

We'll see how a structured approach to analysing problems encountered in LIVE can make everyone's life easier, and how to prove whether the problem is (or is not) the fault of your software. And how to handle that inevitable case where it is.

And we'll look at the problems of implementing uniformity across multiple code-bases and multiple teams delivering multiple releases of multiple features... and where getting your tooling right can give the biggest benefits.

Amongst other things...