Southampton, England, United Kingdom
Mark is a Microsoft MVP, Pluralsight author and open source developer. He works as .NET developer and software architect, building digital evidence management systems in Azure for the police. You can keep up with what he's doing on his blog at markheath.net or on Twitter @mark_heath
Many companies are looking for a path to migrate from legacy monolithic applications, towards a more modern, cloud-based microservice architecture. But there are many choices along the way. How do you pick between two of the hottest trends in cloud architecture at the moment: containers and serverless?
In this session you'll learn about the strengths of both approaches, how to pick the right approach for your business requirements, and some of the key challenges you need to be prepared for.
We'll see how this can work in practice by looking at several key Azure technologies that enable these architectures such as Azure Kubernetes Service, Azure Functions, and Azure Container Instances. And we'll see how the strengths of serverless and containerization can even be combined together into a hybrid architecture providing the best of both worlds.
Building reliable, cloud-based workflows is not a trivial task, and yet is necessary to model real-world business processes that may take many days to complete. There are many challenges involved including: how can we keep track of workflow progress? How can we effectively handle errors wherever they occur in the pipeline? What happens if something we were waiting for never happens? What if we need to run some parts of the workflow in parallel?
In this talk, Mark will show how we can meet all of these challenges with Azure Durable Functions. We'll see how Durable Functions offers an elegant solution for constructing complex workflows out of simple building blocks, resulting in reliable, observable, scalable and efficient workflows.
LINQ is an essential part of every C# developer's toolbox, but are you getting the most out of it? Working with collections of data is a core part of pretty much every application you'll ever write, so becoming more effective at wielding the power of LINQ, has the potential to make a big impact on the quality of your code.
In this talk Mark will introduce several tips and tricks that will take your LINQ code to the next level. We'll look at using pipelines, thinking in patterns, being lazy as well as how to avoid performance pitfalls and extend LINQ.
Why is it that so often, despite our best intentions, our codebase seems to get progressively more and more difficult to work with over time? In this talk, we'll look at the various ways that decisions we made in the past can slow down our progress in the future. We'll see some ways to measure the problem, how you can work with management and developers towards addressing the issue, and ways you can avoid getting too deep into "technical debt".
30 Sep - 2 Oct 2018
Ede, Gelderland, Netherlands