Session submission is now open. If you would like to speak at DDD East Anglia, please submit a session.
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.
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.
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.
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.
.. 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.
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.
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.
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".
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.
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!
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:
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!
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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".
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.
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.
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...