The Code Behind The VulnerabilityBarry Dorrans
I know it's hard to believe, but sometimes Microsoft makes security mistakes. Despite his best efforts to stop this in .NET Barry is here to share stories about the things that turn his hair grey. We're not talking OWASP listed mistakes (well, OK, there's two we're going to discuss that are on the OWASP Top Ten, which is embarrassing), we're going beyond SQL injection covering some of the code behind now fixed .NET vulnerabilities which ended up in Patch Tuesday updates.
By the end of the session you should be able to pour through your own code looking for problems with dictionaries, compression, encryption and more.
Keep calm and easilly manage a gazillion services in Azure!Jan de Vries
Creating an infinitily scalable solution is easy to do with all of the serverless offerings nowadays. But having thousands of service instances running all of the time can make your life quite hard when running in a devops team.
Let me show you how you can keep your head calm and make sure you can track & monitor all requests and information flows with ease! Create a flowing architecture, utilizing Azure monitoring services and of course with a touch of Application Insights. I'll provide you with all the knowledge you need to implement your own serverless architecture ready for production!
Lessons learned applying DDD, CQRS and Event SourcingNeil Barnwell
I've spoken about DDD, CQRS and Event Sourcing before, though not for a while, but this session is meant to show some successes and failures I've had trying to apply this stuff in a couple of real projects over the last few years.
I'll give you a taster for free - these things really needn't be all that complex, unless you make them such. Hopefully I can shine a light on a few traps and pitfalls I've experienced so you don't have to.
From monolithic monster to majestic microservice appCallum Whyte
How do you scale an over engineered monolith intended for millions of users?
How do you fix bugs and add new features to a codebase that's impossible to understand?
How can you avoid rewriting everything yet make the application perform as it was intended?
How do you do all of this while the app is LIVE and being used by many users every day?
The answer: restructure it into small maintainable chunks – microservices!
Callum will discuss the process he followed to transition an app for the NHS into a majestically constructed microservices architecture, the lessons learnt and pain points felt along the way.
We'll take a look at the infrastructure components you can use with limited knowledge to get started using microservices, focusing on utilising Azure Functions and API Management Gateway to build a large API.
Finally we'll take a look into the code and have a look at the iterative changes we had to make to ensure our old monolithic app could scale, such as building a new authentication "service" based on IdentityServer and restructuring specific components into Azure Functions!
Pilot Critical Decision ManagementClifford Agius
This talk explores Clifford's experience as a Boeing 787 Dreamliner Pilot and the critical decision management skills required therein.
As an Airline pilot, you may be required to make a decision often quickly to react to a situation as it presents itself and you will discover a way to achieve this called TDODAR. This model ensures that you achieve a safe outcome for all on board and Clifford often finds himself using the same model when facing a problem whilst wearing his Dev hat and it's yet to fail him.
Introduction to Cognitive ServicesGosia Borzecka
Machine Learning, Data Science, Artificial Intelligence. These all subjects coming to our business really quickly - but do you really need to master them all to make your application intelligent?
Microsoft created a simple API's that any developer can use and integrate into their applications quickly.
This session will focus on various API's and show the few demos how to add them to your apps such as ASP.NET Core, SharePoint Framework and Flow.
So You've Built Your Shiny New AI Model, Now What? AI DevOps!Gary Short
In this session I'll examine the AI DevOps process in Azure. We'll look at the full model lifecycle of train, evaluate, productionise, update.
Industrial IoT using AzureEldert Grootenboer
In this session we will dive into the IoT stack provided by Azure, using IoT Hub and IoT Edge. During this session we will see how to use Azure to incorporate and manage our devices, deliver end to end messaging using IoT Hub, and how to extend our solutions to the Edge. Using the Azure iPaas platform, we expand on this solution to Dynamics 365 using Connected Field Services so we can control the devices, visualize our readings and deliver proactive maintenance.
Git Deep DiveJames World
Are you getting the most out of git? The 2018 Stack Overflow Developer Survey tells us 90% of developers are using git now. Source code is what we produce, so it's arguably the most important tool we use. But do you use it as effectively as you can?
In this talk, I'll dive under the covers of git, and explain in depth the surprisingly simple and elegant design hidden within. With this knowledge, you'll be better equipped to make sense of the sometimes enigmatic yet powerful capabilities git offers.
I'll explain the workflows of a typical advanced git user, show how to make your code more maintainable and leave you in no doubt of when to merge and when to rebase and how to get out of trouble.
We'll then step back and look at some powerful techniques to harness git and .NET together to help us understand more about source code under git's control.
Beginner or seasoned pro, I bet you'll learn something about git you didn't already know!
Take Back Control of your APIsRobert Stiff
In a large distributed environment your API will have more consumers than you can count. It's simply unfeasible to build a new API and then migrate all your consumers across. To borrow from The Eagles: You can check in [code] any time you like but you can never leave [legacy code behind].
In this session I will share a number of different approaches to managing your APIs that will help you decouple your code from legacy consumers so that you can continue developing it, preventing the stagnation that is inherent in legacy systems.
Logging and Alerting with Azure Log AnalyticsSteve Spencer
This talk will explore some of the built in features of Azure that allow you to monitor your applications as well as integrating your own logging and metrics to provide insights into the health of your applications and who is using it.
Finding your service boundaries - a practical guideAdam Ralph
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".
Deploying Functions to Azure with OctopusDeployJoel Hammond-Turner
Azure Functions are the basic building blocks of "serverless" computing in the Azure stack. But whilst the technology provides a (fairly) smooth path for developers to play with it, in the enterprise you still can't just deploy to PRD from the desktop.
And even deploying from a GIT repo isn't necessarily enough control for your business - just as with traditional software and services you need reliable, repeatable deployments.
At Landmark, this is exactly what we need to do, and so in this talk, I'll show how we can use our old favourite, OctopusDeploy, to take an Azure Function from our build process and deploy it in just the same way as we do for other software.
Headless UI testing with Chrome and PuppeteerRichard Wilde
Wouldn't it be nice to be able to UI test your code changes before you check into source!
Unit testing helps us when writing any sort of application, however we often end up writing unit tests for small pieces of logic that don't really matter and sometimes miss out on the bigger picture. As a developer we tend to shy away from Web UI testing as the feedback loop is just too slow.
In this demo led presentation we will take a look at a toolset that gives us far faster feedback. I will cover :-
- how to get up and running
- show how we can take screen grabs and generate PDF's
- show some basic testing scenarios using a SPA (including image comparisons)
- show how the page object pattern is useful
Welcome to Chrome(ium) and Puppeteer!
Puppeteer is a Node library which provides a high-level API to control headless Chrome (AKA Chromium) over the DevTools Protocol. It can also be configured to use (non-headless) Chrome.
Developer Productivity!Dan Clarke
Are you the type of developer that likes to Get Sh*t Done?
If you take a room full of developers, the deviation
betweeneach developer's productivity level is massive! A task that might take one developer half an hour, might take the next developer an entire day! Or more! And the quality of the solution will be wildly different too.
In this day of age - the developer rules in terms of productivity. We're one of the only industries where we can easily automate a lot of our menial tasks, with hardly any work. And there are so many tools already available to make us even more productive. But a surprising number of developers don't take advantage of automation or
tooling,and do everything the hard way - using the standard tools that they've been using for most of their career.
In this talk, we'll be covering quite a lot of topics. From compound learning, to note taking, to tools and automation (with demos of tools like LINQPad, Resharper, etc), to using the CLI effectively, to the Pomodoro Technique, to GTD, and even more!
Join me for a fast-paced talk on the tips and tricks I've found along the way that has saved me an insane amount of time!
Introduction to Windows Mixed Reality development using Unity and the Mixed Reality ToolkitDavide Zordan
Mixed reality is the result of blending the physical world with the digital world. It is the next evolution of human, computer, and environment interaction and unlocks possibilities that before now were restricted to our imaginations. The Mixed Reality Toolkit is a collection of scripts and components intended to accelerate development of applications targeting Microsoft HoloLens and Windows Mixed Reality headsets. In this session, we will explore how to fast-start Windows Mixed Reality development using Unity, the Mixed Reality toolkit and the Universal Windows Platform.
Containerise "legacy" .NET applications for a new lease of lifeShahid Iqbal
As our applications evolve we are often faced with difficult choices of how we support our older systems whilst taking advantage of newer platforms. With the advent of .NET core many companies are looking to write all new projects in .NET core and target Linux using containers. However what about their existing full framework .NET applications, do they need to maintain two totally different build & deployment and production systems to support both old and new applications? This talk will cover the following areas:
Introduction to Windows containers.
How to choose which container variant to use.
How to containerize legacy applications.
Vision of a unified build/deploy and production platform with both Windows and Linux applications running alongside each other.
You're the Tech Lead - you fix it!Joel Hammond-Turner
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...
Learning Kotlin as a C# DeveloperJoe Stead
There are hundreds of programming languages out there now, more seem to crop up every week, trying to learn them all is an impossible task. Learning Kotlin, like any language, presented various challenges. Is my code idiomatic? Is this a good use of the language, or am I abusing the syntax to solve my problem?
We'll start with a basic introduction to Kotlin, how to get up and running with relative ease, and then we'll start comparing simple applications written in C# and seeing how we could write them in Kotlin instead.
Finally, we'll share ideas to help you start writing Kotlin immediately, without rewriting all of your existing .NET code.
Hunting typosquatters with F#Chester Burbidge
Integrating life with cognitive servicesEldert Grootenboer
In this session, we will see how we can get data from the real world, and use this to drive our business. Thanks to Microsoft Cognitive Services we can easily work with data from the real world, like text, images and videos. By integrating this data into our processes we can make even more engaging and better solutions.
Microservices - What I’ve learned after a year building systemsNathan Gloyn
This talk goes into my experience during the last year as part of a team building a system that is based on microservics architecture.
Whilst I'll mention the technology used this talk won't be about the technology more about the lessons I've learnt.
I'll cover how we built the system, deploying the code & most importantly how to support the system.
ASP.NET Core loves Docker: from 0 to Azure in 60 minutesMarco De Sanctis
Should I care about Docker if I'm a developer? What are the advantages and how can it make my life easier? How painful is to port an existing application to Docker and get it to production?
These are some of the questions we promise to answer during this talk, and you'll get super excited seeing how seamlessly Docker can plug in your development experience.
We'll start from the very basics of Docker, so you will have no problems on following it even if you've never used it before.
And then we'll see how we can containerise a non-trivial existing ASP.NET Core solution and have it running on Linux, thanks to the support of Visual Studio 2017.
After executing it locally on our machine. we'll explore which options we have in order to run it on the cloud, we'll set up a CI/CD pipeline on Visual Studio Team Services and we'll deploy it to AKS (managed Kubernetes) in Azure.
Introduction to Managing SharePoint Online using PowerShellAndy Dawson
SharePoint Online management using PowerShell provides powerful capabilities to automate common tasks. This session covers getting up and running with PowerShell for SharePoint Online, including installation of the required components, pros and cons of the available options and some sample scripts to perform common actions. If you're a newbie to SharePoint Online automation with PowerShell, this is the session for you!
Deploy IoT Edge in 45 minutes (and live happy)Marco Dal Pino
Do you want to build hybrid solutions for the IoT? Want to bring the power of the cloud locally? Do you need to install and run applications for artificial intelligence in even disconnected situations? Or do you still run Azure services and custom applications directly on IoT Cross platform devices? And maybe then check everything centrally from the cloud using Microsoft services and security? Then you need Azure IoT Edge!
Building stateful serverless services using Azure Durable FunctionsEldert Grootenboer
With the addition of Azure Durable Functions we can now create long running and stateful function orchestrations.
This is a great addition to Azure's serverless services as it allows us to easily implement function chaining and fan-in/fan-out messaging scenarios. In this sessions we will dive in to the possibilities and inner workings of this new technology, and will find out how we can use it to make our applications even better.
An introduction to how Entity Framework Core works insideJon P Smith
Entity Framework (EF) is Microsoft’s recommended database access library, with Entity Framework Core (EF Core) being the latest version. EF Core is very similar on the outside to the original 6.x version of EF, but very different underneath. In this talk Jon P Smith will describe how to use EF Core and what is going on inside the library. The session shows the inner workings of EF Core, live code examples, performance issues and database migrations. This talk is suitable for three groups of developers:
- Developers who aren't currently using EF and want to know if its worth changing to EF Core.
- Developers using EF6.x who want to know what is different about EF Core.
- EF Core users who want understand more about what EF Core is doing "under the hood".
I assume you know C# and have some awareness of relational databases.
Web Assembly, Blazor and the Future of Web DevelopmentJoseph Woodward
Web Assembly has been on the tip of everyone's tongue recently with the unveiling of Blazor, Microsoft's foray into bringing C# and ASP.NET into the browser.
In this talk we'll start with a deep dive into the history of Web Assembly, what it is, how it works and how other languages such as Rust and Go are battling for developer mind share by offering compelling support for Web Assembly as a compilation target.
Next we'll load up our IDE and dive into Blazor, Microsoft's attempt to change the shape of front end development in ASP.NET via Web Assembly.
Better Contract Testing with PactThomas Shipley
[First Time Speaker] Contract testing shows some promise when testing microservice architectures. Why setup integration tests? They are often slow and hard to maintain, as the QA environments they rely on ultimately break. Instead, services can be mocked out and teams owning the mocked services can run and maintain Contract tests. Validating the shape of data returned hasn’t changed between releases. With these Contract tests in place Integration tests are less useful. It is a nice idea but there is one big problem. Contract tests go out of date even with the best of intentions! There is often a disconnect between the service providers and consumers which causes Contact tests to drift from reality. Something I have witnessed first hand. This talk will introduce Pact, a contract testing framework with a difference. You will see how to avoid out of date Contract tests. By letting your service consumers drive your Contract test definitions instead. Saving your teams time and creating a more reliable Contract test suite.
Apps, algorithms and abstractions: decoding our digital worldDylan Beattie
Picture the scene: you’re on a train, your phone goes ‘ping’, you take it out of your pocket and hey — someone sent you a message! It’s a picture of a cat doing... daft cat stuff? You send back "LOL", you put your phone back in your pocket… but have you ever stopped to think about what’s actually involved in making that happen? Inside even the most basic smartphone there are literally hundreds of innovations, algorithms and inventions — but how do they really work? How were they developed? And what’s the next generation of algorithms and applications going to look like? In this talk, we’ll take a deep dive into the technology behind those everyday experiences, and demystify the algorithms and abstractions that make our digital world go round. We’ll look at everything from network addressing algorithms, frequency-hopping cellular data networks and shortest path optimisation, to wavelet compression, Fourier transforms and media encoding schemes. Whether you’re a programmer, a product owner or just somebody who loves using the latest tech, after watching this talk you’ll never look at your phone quite the same way again.
Your First Alexa Skill with .NET CoreSteven Pears
Voice is being used more often in daily lives, in our homes devices such as the Amazon Echo are becoming smarter and are a convenient way of performing tasks and asking questions – but they don’t always do exactly what you want. As developers, we can create our own skills for Alexa that allow us to fill that gap. In this session we learn how to write our first Alexa Skill. Using AWS Lambda and .NET Core we learn the concepts that allow us to build conversations; finding out what our users are asking for and giving them back information with Alexa’s voice – without them ever having to lift a finger.
Don't let your serverless solution become the frontpage news!Jan de Vries
Designing a highly distributed system is great of course, but also opens up a lot of possibilities for attackers!
Are your endpoints secure, is your code fortified, how about your infrastructure?
Lot's of stuff to think about and if that's not all, there's also the question on how to do all of this in a serverless world?
I'll show you some of the best practices there are at the moment and will give you some advice on how to design and develop a system which is fast, can scale infinitely while still being secure! There will be a lot of code, diagrams and configuration, so brace yourself for this session!
Automating business processes using Microsoft Flow and Logic AppsSteve Spencer
As part of the Office 365 suite of applications Microsoft Flow provides a great tool set that give semi technical people the ability to build their own personal automation. This talk will explore some of the features of Flow, its relationship with Azure Logic Apps and discuss how a flow can be operationalised and controlled as part of a DevOps process
Spot the difference; automating visual regression testingViv Richards
This session looks at common issues with just relying on end to end automation testing tools, using examples to demonstrate common pitfalls and how visual testing can help add another tool to your tool belt.
The talk looks at why we automate tests, the issue with just manually testing, common end to end automation pitfalls, a brief introduction to visual testing and finally a look at common issues with visual testing and ways to overcome them.
Through the use of interactive examples the audience will gain an understanding of why relying on just manual testing can become an issue and how too much automation has a negative impact by looking at testing anti-patterns. The audience will also learn what visual testing is, what tools are available, some of the common pitfalls of using visual testings as well as tips on ways to overcome them based on experience of creating a custom visual test framework at my current employer.
Kubernetes .NET and AzureShahid Iqbal
Everyone seems to be talking about Kubernetes with companies seemingly tripping over themselves to support or adopt it.
In this talk we'll introduce Kubernetes, discuss the key concepts of the platform, it's high level architecture and how to get a Kubernetes cluster up and running in minutes.
We'll talk about and demo deploying .NET applications to Kubernetes and we'll finish with a discussion of the future where you can deploy both legacy and modern .NET applications to the same platform.
If you're interested in Kubernetes and you're not a .NET developer this session still has something for you
Open Source isn't Scary!Steve Gordon
In this talk Steve will take you on a journey from Open Source newbie, to core contributor and project maintainer. Steve will share his personal experience and along the way impart some practical Git and GitHub advice, discuss etiquette, look at pull requests and dive into why contributing to Open Source can be great for your career and the community!
During the talk Steve will focus on his contributions to the allReady project, run by the Humanitarian Toolbox. This is an example of how open source software and its contributors can help organisations save lives, by "coding for the greater good". Steve made his first ever pull request to allReady in 2015 and since then has made over 180 more as his passion and confidence has grown.
Open Source can be intimidating for newcomers, but it needn't be. There's a great community of people who work together to build great software. Everyone has a place and can contribute. By working on open source projects you can learn new skills and experience new technologies on your way to furthering your career and mastering your trade. You'll leave this talk inspired; ready to clone some source code and excited to make your first pull request.
How can monitoring save your baconSean Farmar
Navigating the HttpClient minefield with HttpClientFactorySteve Gordon
A simple requirement can quickly become complicated! You want to make a HTTP request from your application to an external service. Simple you say! Grab the good old HttpClient and off we go! But it's not that simple; first we have to worry about socket exhaustion. That's okay, we can solve that; singleton HttpClient, here we come. But now we have a new problem; DNS TTL is not respected and if that external service moves, we're done for! So what now?
Enter HttpClientFactory, a new feature in ASP.NET Core 2.1 which provides an (opinionated) approach to help navigate the minefield. In this talk Steve will explore the problems that HttpClientFactory helps solve before looking at demos of how we can use HttpClientFactory in our code. We'll explore the most basic usage, through to more advanced named and Typed clients. We'll then explore how to add and write outgoing request "middleware" handlers, similar to the incoming ASP.NET Core middleware pipeline. We'll wrap up by looking at the integrations with the popular resilience and transient-fault-handling library, Polly, which provide powerful policies to build reliable services.
If you're building cloud native (micro) services or libraries that need to communicate over HTTP, this talk is for you! It's time to start leveraging the power of HttpClientFactory.
Building a CI/CD pipeline for your InfrastructureSam Cogan
We're all used to using CI/CD to build, test and deploy applications. With the advent of Infrastructure as Code we can now do the same thing with our Infrastructure. Infrastructure deployments that where once the domain of IT operations can now be handled just like our application code and get all the benefits that come with that. In this presentation, we'll look at using techniques that have been used in software development for years and applying them to Infrastructure. This includes version control, testing, build and release management, to help produce repeatable and reliable releases of your infrastructure alongside your applications. We'll cover a real example end to end using Azure and Visual Studio Team Service, but with techniques that can be applied to any infrastructure provider and CI/CD platform.
Security in Cloud-NativeRobin Minto
Cloud-native is an approach that fully exploits the advantages of the cloud - it's how you build and run your applications to allow easy scaling and continuous deployment. You may have seen the Twelve-Factor App methodology (https://12factor.net/) for developing applications that embrace a cloud-native philosophy but with that, there's little or no guidance on security.
Security can't be an afterthought and cloud-native is no different. This talk looks at how to approach security for an app deployed to the cloud. Can you forget about infrastructure security? Where should you focus your attention? Is cloud-native more secure?
We'll consider the similarities and differences between traditional apps and cloud-native apps. We'll look at how you can avoid the most common security vulnerabilities that affect cloud apps and we'll look at approaches applicable to both Linux and Windows. You'll come away knowing how to be more secure in cloud-native.
Am I doing deployments right?Matteo Emili
How Microsoft does DevOpsTiago Pascoal
This is NOT a session about MS DevOps tools. This is the story of how the VSTS team transformed from shipping an on-premise server product every couple of years, to shipping a cloud service multiple times a day. In the process, almost everything about how this team of 800 people work has changed. We had to figure out how to do agile at scale, how to transform into a microservice cloud architecture, complete restructure of teams and roles, threw out a suite of 10’s of thousands of tests and started over, went from almost 0 telemetry, to 8+TB/day and figuring out to do anything meaningful with all that data. Many mistakes were made along the way, and lessons learned that I’ll be sharing
TPL Dataflow - The Best Little Async Library You've Never Heard OfJoel Hammond-Turner
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".
Team Values for Product InnovationAbid Quereshi
In 1986 the Harvard Business Review featured an article describing how Japanese innovation was kicking butt. The paper "The New New Product Development Game" was the inspiration behind Scrum, which is now the most popular product development framework in the world of Agile Software Development.
What was the secret sauce in those teams? This workshop give you the opportunity to discover for yourself what it was like to work in those teams.
Using Domain-Driven Design with Entity Framework CoreJon P Smith
Microsoft's Entity Framework Core (EF Core) provides a number of features that allows you to apply a Domain-Driven Design (DDD) philosophy to the classes that EF Core maps to the database. This session is about why DDD is useful when dealing with a database, and how you can implement DDD with the EF Core library.
This session will be useful to anyone that uses Entity Framework for database access and wants to see if DDD is a useful approach to adopt. Jon show how to build an EF Core class in a DDD style, and why that is useful. Jon also covers how to build business logic using the DDD philosophy, with worked examples.
Building your first dashboard with Azure PowerBI EmbeddedJoel Hammond-Turner
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. But why are they so hard to implement? Why are they so often a last-minute add-on to the software you develop?
Microsoft's Azure PowerBI Embedded product lets you capture data, analyse it and present it on dashboards that live within your application - easily.
In this session, I'll take an existing instrumented application, pipe the data into Azure and demonstrate just how easy it is to create a rich dashboard to monitor the application. And I'll show how to use Power BI to get deep insight into your software - and deliver that insight to your users.
Continuous Delivery - A continuous improvement journeyColin Mackay
A lot of people look at continuous delivery and think that's a big step, and back away from it. It doesn't have to be that way. It isn't as insurmountable as it first looks. 4 years ago I had never done any automated deployments at all. Today I have three projects that can deploy quickly at almost any time with minimal downtime, one of which has zero downtime. And all this is from a simple button click on the build server. This didn't happen all at once. It was through a series of incremental steps that we got here. Not all the steps we took worked out, some introduced new pain points for us that we had to deal with, but on the whole we managed to improve a little each time. We're not finished either, there is still more we can do, and the projects are always changing to meet the changing needs of the business which presents new challenges. In this talk I'll show how we started with a Continuous Improvement Theme as a way to help break down the problem, and then move forward in smaller baby steps, occasionally falling down and having to pick ourselves up, slowly gaining confidence until we were walking confidently with our understanding of what we were doing. Although some specific technologies will be shown or mentioned, the ideas presented are not technology specific.
Successfully Decomposing Your Monolith or UpdateUser Means Nothing To MeSean Farmar
Designing a system is hard, it’s even harder to build a distributed (microservices) style architecture…
Let's try and walk through a simplified example of carving out our bounded contexts and the processes, finding our service boundaries, on the way to building better applications.
We will focus on moving from "monolith" to "distributed" thinking, moving from one single entity
drivendata model to multiple vertical bounded contexts.
Take Over World? Pfft, AI Can't Get Simple Predictions RightGary Short
So I speak at a few conferences, and it's plain to see that AI is the new hot thing. Everyone is talking about it. Well fine, but AI, or ML specifically, kind of sucks for a lot of stuff. In this session I'll show you under what conditions ML fails, and how to mitigate those failures, and I'll do it in the medium of predicting football results.
WebAssembly and BlazorJames World
Now you can run .NET in the browser with no plugins and no transpilation required - not a Silverlight download in sight - this is exciting stuff!
Steve Sanderson wowed us last year with his prototype of Blazor running on WebAssembly. This year it's now backed officially by the ASP.NET team. It's still experimental, but it's getting better all the time.
In this talk, I'll explain the architecture and demonstrate the technology, so you can find out what all the excitement is about and get up to speed on the latest developments.
Quantum Computing: Don’t PanicAnita Ramanan
Heard of this ‘Quantum Computing’ thing but don’t know what all the fuss is about? Want to learn more about what makes quantum computers so special and how Q# can help? This session will explore quantum computing from the ground up (no previous knowledge required) and give an introduction to how Microsoft’s Quantum Development Kit can help us bring theory to life.
- Quantum Mechanics: Concepts 101
- Quantum Computing 101
- Physical Quantum Computers - requirements and examples
- Q#/QDK Hello World (code demos)
- Quantum Mechanics: Concepts 101
#FAIL - Lessons from infosec incidentsRobin Minto
Securing a web application is a challenge. The internet is awash with malicious traffic and web applications are globally accessible. Don’t make it easy for them and the baddies will move on and find someone else to annoy.
We’ll look at the risks facing web applications, the basic steps you can take so that you don’t make yourself a target and the things you should do to avoid becoming a data breach statistic. We’ll also look at lessons that can be learnt from mistakes that others have made.
We’ll demo some of the techniques and tools in both attack and defence with examples for any web application developer.
Introduction to SharePoint Framework (SPFx)Gosia Borzecka
SharePoint Framework (SPFx) is the new framework for creating customizations for SharePoint using only client-side code.
In this session, we will better understand how the SharePoint Framework is working, what tools we need and how easy we can develop new Web Part and Extensions and next deploy them on Azure and SharePoint.
How to write a Git library in C# from ScratchDong Xie
You are forgiven if you don’t know there isn’t many original git libraries around. These days most languages “wrap” libgit2 to give their developers access to the git functions. And there is jgit for the Java world, with a “machine” translated ngit in C# out-sync with upstream long time ago.
The trouble is all these won’t work for us because we are mad enough to develop for UWP, the sand-boxed environment, two years ago. Given we are mad, there is nothing to lose to try the Git library too, and it turns out Not That Scary at all.
Come to the talk to see the pieces of what we named as robin-git. Nothing explains Git better than the source code of a git library, especially in your favourite language C#? Given we wrote it, we could explain everything Clearly to you, not rely on the missing comments at all. (Probably can only guarantee the Clearness up to four months old code parts).
Improving System Resiliency via Chaos EngineeringJoseph Woodward
Advances in Cloud technology means systems are becoming increasingly more distributed and complex. Large monoliths are being split up into microservices and Function as a Service (FaaS) and Serverless are becoming more common. The very nature of distributed systems mean they're far more prone to problems than similarly-scoped monoliths; this makes predicting or preventing possible failure modes increasingly more difficult.
In this talk we'll look at how we harness Chaos Engineering, a discipline pioneered by Netflix, to better understand our systems, their failure modes and how we can use this information to improve system resiliency and reliability.
We'll start by looking at a typical microservice architecture and the chaos that's inherent to a distributed system, we'll then move onto understanding Chaos Engineering, the history of it and what Chaos Engineering is and isn't. We'll then look at how we can successfully run Chaos experiments such as fault injection and some of the existing tooling that's available to us.
By the end of the talk you'll hopefully leave with a better understanding and appreciation of the inherent dangers of distributed systems, and how you can introduce Chaos experiments into your systems to gain better understanding, visibility and predictions around failure modes and how you can fix them before they bite you.
Introduction to Azure Service FabricSteve Spencer
Azure Service Fabric is the Microsoft microservices framework and this talk explains how to build applications that can be deployed in Azure or on your own infrastructure. Service Fabric lets you deploy your own existing services or build them using the Service Fabric Framework to take advantage of built-in microservices features that Azure Service Fabric provides.
A case for on-premise: why you can do brownfield DevOps tooMatteo Emili
What did I learn trying to migrate teams from legacy to modernMatteo Emili
CI/CD of .NET applications to KubernetesShahid Iqbal
Kubernetes is rapidly becoming the industry standard platform for application development/hosting. Coming from the Linux world Kubernetes can be a little daunting for .NET developers, especially as we have a world with both Windows only full .NET framework applications along with new .NET Core applications. This talk will cover: Fundamental concepts around Kubernetes Discuss the options available to .NET developers for containerising their .NET applications Demonstrate building a CI/CD pipeline to deploy .NET applications to a Kubernetes cluster
Accessibility in Modern Web ApplicationsStuart Ashworth
The web’s original mission was about opening up information and communication to everyone, regardless of where you might be in the world and regardless of who is accessing it.
In this talk, we’ll focus on the biggest obstacles these applications impose on people with disabilities and what steps we can take to ensure all users have a fantastic experience. Our discussions will be kept framework-agnostic with the techniques and approaches able to be applied to all applications.
User Storymapping for BeginnersColin Mackay
Sometimes it is difficult to work out how to prioritise the backlog and effectively work iteratively. What do you put in your MVP (Minimal Viable Product)? What then goes in each incremental release to give your users more and more useful functionality? Storymapping is a technique for solving this problem and getting your solution to your users faster.
In this highly interactive session I'll explain how you go about creating a story map and I'll get you to create one. Lots of sticky notes later you should have a fairly good grasp and be able to use the same technique on your own projects to better manage your backlog.
Creating serverless applications using Azure's holy trinityEldert Grootenboer
With the addition of Azure Event Grid, we now have the holy trinity of serverless in Azure. We have Azure Functions to run our custom code, Logic Apps for our workflows and easy integration, and finally Event Grid for our messaging needs. And all this truly serverless, meaning highly available, dynamic scale and allowing us to focus on logic instead of infrastructure.
Azure Machine Learning for DevelopersSteve Spencer
As a developer I wanted to get an understanding of machine learning and with the arrival of Azure Machine Learning I got my chance. This talk will go through from a developers perspective the highs and lows of machine learning. I will introduce the tools, show how easy it is to use and then talk about what us as developers can add to the process
The Life and Death of Software FactoriesAbid Quereshi
There have been a few notable attempts over the past four decades to turn software development into an industrial activity like automobile manufacturing or construction. Why is this soooooo wrong? Where did we go wrong? Programmers know that software development is a creative endeavour, a craft, an artisan activity which requires a skilful crafter to feel the wood grain before they cut.
This talk will take you through a 16 year Japanese experiment in large scale software factories and share what the learned about the true nature of software development.
What sorcery is this? Xamarin Forms in the web browser
Terraforming your ancillary servicesPiers Karsenbarg
We all know that Terraform can be awesome for deploying loads of servers to every known cloud provider ever, but you can also use it to set up your ancillary services as well. In this talk I'll be doing a (very) brief introduction to Terraform followed by more in depth details on maintaining your Github set up, DNS (through Cloudflare in this case) and PagerDuty in a more manageable and consistent way.
Analyzing flight data in real time using Cosmos DB, Azure Functions and Power BIJames Broome
Cosmos DB is redefining the database in the age of cloud; globally-distributed, secure, PaaS, multi-model, multi-API database with a choice of consistency models, enterprise SLAs, encryption and guaranteed latency. This session will cover Cosmos DB’s main features in the context of an Aircraft tracking use-case developed by endjin. We will cover the benefits that made Cosmos DB the right choice to support a global, mission-critical application. There will be a live demo of the solution architecture, operational system, example queries, and performance optimisation strategies. We will also show examples of how we integrated with Azure Functions and Power BI to create real-time analytics over the ingested flight data.
Lessons Learnt Building Resilient MicroservicesJoseph Woodward
With microservices being the latest hot trend in software architecture, promoting benefits such as increased business velocity, self-organising autonomous teams and increased scalability, they can often lead to developers focusing too much on the business valuable whilst forgetting that the distributed nature of microservices mean they're more prone to failures than similarly-scoped monoliths.
In this talk we'll look at some of the best practices, patterns and considerations one can take to improve reliability and resiliency in your microservices architecture, including topics such as:
- Managing transient network failures
- The dangers and trade-offs of DRY (Don't repeat yourself)
- Effective timeout strategies to prevent cascading failures across your systems
- Dealing with behaviours such as the the 'thundering herd problem'
- Patterns such as exponential backoffs, bulkheads and retry policies
- And more
It's not all Debug.WriteLine
A rapid tour through learning how to use Visual Studio to debug applications, starting from the classic logging to the console and moving on to using the power of the integrated debugging tools. While this session will use C#, the techniques are widely applicable to other languages. Among other things, we will learn how to use features such as conditional debugs, debug single threads in multi threaded applications, using edit and continue. See how Data Tips can make your life much easier, and how you can use them to your advantage. For the XAML devotees, we will also look at how to use the live visual tree and live property inspector to debug XAML apps at run time as well.
Automating your test infrastructure with KubernetesJoe Stead
As a developer, I find the most important job I have isn’t writing code, it’s shipping code that delivers value, and code only delivers value if it works. At a company without the most resources, we need to be clever, which is why we relied on Kubernetes to help automate our test infrastructure and increase confidence in our product.
Kubernetes is container orchestration - but that doesn’t mean you need to be a docker expert to take advantage of the platform. Testing is imperative to any product, but it can be hard. Long running tests can be painful, especially when running them concurrently isn’t possible because of resource constraints, with kubernetes, we can address this. Tools such as selenium grid can be difficult to orchestrate and deploy, but with kubernetes, it is significantly simplified.
Together, we’ll explore how we use Kubernetes to automate our test infrastructure and have greater confidence in our product, and you will learn how you can do the same.
Product Management and Continuous Delivery - a happy marriage?Matteo Emili
Antlr 4, the Honey BadgerDong Xie
After you get the Why, I’ll show you around the Antlr 4 universe, with real code.
Hopefully you’ll get to learn a new thing equally marvellous as Roslyn, even for a C# dev.
Getting the first PR into .NET and other tales from an OSS contributorAdam Ralph
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.
Code on the roadAdam Ralph
Last summer, not content with only working from home, Adam turned the remote working dial up to eleven. He bought a camper van, a couple of EU SIM cards, and... hit a traffic jam near Basel. Seven months and seven countries later, he realised the ski season was starting. Back home to Switzerland it was, to reflect on his experience over a pot of hot cheese. Join Adam as he shares the gory details of the challenges he faced on his journey. Discover the tips and tricks he learned to overcome them. And finally, get the answer to the big question: Would he do it again?
PowerBI and Visual Studio Team Services (and Team Foundation Server)Abid Quereshi
What does good look like? What does bad look like? What do we look like? What does anything look like?
How do you know if your development operations is a pot of gold or a pile of rubbish.
Fear not. PowerBI can make even a pile of rubbish look slick. Look good even when your not, by reporting on your development operations in Team Foundation Server or Visual Studio Team Services with PowerBI.
Into the cloud with AWS and ServerlessAdam Surgenor
The serverless framework makes it very fast and simple to get an application into the cloud using only the code you actually care about. I'm going to live code a simple application with a database into AWS with the minimum effort, code and fuss.
Databases and DevOps - can they be friends?Matteo Emili
Life of a Garage QuantAndrew Chaa
Should I buy Bitcoin and other cryptocurrencies? Many say it's devils scheme to take away your savings. Some say you have to jump on to the rocket. If I do, how can I be a "Intelligent Investor", not a reckless speculator?
I've been buying and selling crytopcurrencies but keep losing my hard-earned money.
I'd like to execute my strategy automatically, so that I can focus on my day work, while my lambda's working hard to make money.
I'm just curious what the fuss is about bitcoin.
If you have any of the above questions, please come to this session. I'll share my not so secret life of a garage quant.
The session will cover
- Basic concepts of trading and trading jargons
- Borrowing ideas from great traders
- Testing strategies against the past data on spreadsheet
- Let's build an App upon GDAX api
- Push it to Lambda with .NET Core
Become an unhappy programmer at work by learning functional programming in your own time.Ian Russell
I've been semi-jokingly adding the following to the abstracts for my F# presentations for quite a while now:
"WARNING: Functional Programming in F# is addictive and may lead you to feel less favourably towards your current programming language. :)".
I now fully believe it because it's how I feel every day working on increasingly complex C# apps with their hard to replicate side-effect driven bugs.
F# is expressive and concise which leads to less code to maintain. The incredibly powerful type system eliminates many of the bugs that plague C# codebases like NullReferenceExceptions. The interactive window will change how you work, allowing you to easily try out ideas until you are satisfied.
There are many falsehoods bandied about F# and where it can be used and how hard it is to learn. In this session I will destroy these myths and show you just how powerful F# is for writing the LOB apps we write every day.
Analysing visual content using HoloLens, Computer Vision APIs, Unity and the Windows Mixed Reality ToolkitDavide Zordan
Do you want to explore how to build advanced user experiences leveraging the power of the Intelligent Cloud and the Intelligent Edge? Are you interested in both Mixed Reality and Artificial Intelligence? Come and explore how to build a fully working app using Unity, Visual Studio and the Computer Vision APIs leveraging the capabilities of the HoloLens device including gestures, speech recognition and integrated sensors.
Azure In Action - CosmosDB, Functions and ServiceBus in Perfect HarmonyJoel Hammond-Turner
There's so many parts to Azure, it's sometimes hard to decide what to use and when. Do I use TableStore or CosmosDB? Would BlobStore be better? Should I host a full-fat .Net service in a VM, or stand up an ASP.Net Core WebApi? What about functions? The choices are myriad.
In this talk I'll describe how at Landmark we made these kind of decisions as we implemented some new features in our product. I'll talk about the questions you need to ask to make those decisions, where we went wrong, and how we succeeded in the end.
I'll describe in detail how we used CosmosDB, Azure Functions and Service Bus together to provide a Compliance Audit trail feature that would scale properly, work reliably, be trivial to use, and that wouldn't break the bank.
SOA lessons learnt (OR Microservices done better)Sean Farmar
Service Oriented Architecture has been around for a while, now Microservices is the new black, that’s cool, but can we learn from when we failed and succeeded implementing SOA?
There are some really useful lessons we can take and avoid the pitfalls.
From NT4 to .NET Core: Two Decades of Continuous ImprovementDylan Beattie
Dylan Beattie started building data-driven web applications on Microsoft Windows way back in 1997, when IIS was part of the Windows NT 4.0 Option Pack. Two decades later, the web has completely transformed the world we live in, and the software industry has changed almost beyond recognition. Agile, devops, virtualization, JSON, cloud, NoSQL, mobile apps - and Dylan is still building data-driven web applications on Microsoft Windows. In this talk Dylan will share lessons and experience from two decades of building web apps on Microsoft platforms, but this is more than just a walk down memory lane. As each new generation of developers enters our industry, they're starting out a journey of their own - and maybe there's some insight from the last two decades that we can share to make their journeys easier. How can you stay focused on solving the important problems when there's so many exciting new patterns and frameworks you should be investigating? How can you spot the difference between genuine innovation and a passing fad? How can you tell when a new technology is mature enough to start using on production systems? We'll talk about source control and collaboration patterns. We'll talk about things like continuous integration, monitoring and infrastructure, and look at some of the timeless challenges of software development.
Is UWP/Microsoft Store a dead story? The Code Reader+ storyDong Xie
When the world is full of iPad and mobile phones, surely it is mad to develop an UWP app for Microsoft Store?! Come to listen to the Code Reader+’s story.
We will guide you over the why? And show you the how. End with sharing our first-hand experiences of the full life cycle. In case you are mad enough to consider UWP too, come join us on this journey.
Tech side, we will talk about the basics of UWP, the MVVM, the XAML, Testing and Packaging, Release Process etc.
Business side, we’ll share our reasoning, our failures, our Marketing strategy (or the lack of).
Deep Learning in the world of little poniesGaliya Warrier
In this talk we will discuss computer vision, one of the most common real-world applications of machine learning. We will focus on image classification task and will demonstrate how you could build one to classify characters of "My Little Pony" TV Series [or Pokemons, or Superheroes, or your own custom images]. You will learn about the fundamentals of deep learning, convolutional neural networks and transfer learning using Keras (Python) - based examples.
Mobbing XP in about an hourAbid Quereshi
Requirements analysis on Monday and Tuesday, the next seven days coding it up and the last two hours of the sprint to test it. Sound familiar? Break free from your mini-waterfall habit!
How can Scrum teams analyse requirements, design, code, test, integrate and deploy simultaneously? Come and join us for a hands-on “Mob Programming” exercise and discover why Extreme Programming practices are essential for software Scrum to work. You will have a chance to experience all 12 XP practices in about an hour.
Microservices and Containers: How Service Fabric can help build your distributed applicationSteve Spencer
Whether you have existing services or containers or whether you are building a new system from scratch there are numerous ways in which you can deploy. Managing and deploying your microservices application can be complicated. This talk introduces the Azure Service Fabric and shows how you can take existing services and containers and deploy then on your own infrastructure, in Azure or another cloud provider and how you can manage these applications and build new services to take advantage of the Service Fabric platform.
Docker for .NET DevelopersSteve Gordon
Is Docker forever on your list of things to explore? There's no better time than now…
In this talk Steve will introduce you to Docker, an application packaging and containerisation technology that opens new possibilities for development and deployment of your ASP.NET Core and .NET Core applications. Steve will share with you the Docker journey that his team are on, exploring their motivations for using Docker, the benefits they've achieved and the workflows they have developed.
We’ll learn about the core terminology and concepts that .NET developers need to understand in order to begin working with Docker. Steve will share demos which show how easy it is to start leveraging Docker in your own ASP.NET Core projects. Finally, we’ll look at a complete CI-CD pipeline using Docker and Jenkins. Steve will explore the AWS Elastic Container Services (ECS) architecture Madgex have built to enable rapid, continuous delivery of their microservices.
You’ll leave this talk with the knowledge you need to get started using Docker in your .NET Core projects and excited about the value that Docker can add to your workflows and deployments.
Securely Authenticating to Azure Services with Managed Service IdentitySam Cogan
Having your application communicate with other services in Azure can be a painful experience, especially when it comes to authentication, you end up storing secrets in your application settings or messing around with certificates for hours. In this session we'll explore the new Azure Manged Service Identity (MSI) feature that allows the service hosting your application to assume an identity and use this to seamlessly authenticate with other services. We'll explore what MSI is, how it works and where it is useful, followed by some demos of using MSI to provide identity to virtual machines, app services and Azure functions.