Blazor - The future of frontend is hereChris Sainty
What started as a prototype demo at NDC Oslo in 2017 has become one of the hottest technologies in the .NET ecosystem.
Blazor is Microsoft’s new frontend framework for building single page applications using C#. That’s right, C# running in your browser. No plugins, transpilation or voodoo magic involved.If you’re a .NET developer who’s looking to up their frontend game, or curious about how this all works and thinking of making a switch, then this is the talk for you!
Join Microsoft MVP and Blazor expert Chris Sainty as he gives an introduction into this game changing new framework. You’ll explore Blazor's flexible architecture, rendering models, syntax, project types, component model and more.
Solving the Travelling Surveyor problem in .Net using Google OR ToolsJoel Hammond-Turner
The "Travelling Salesman" problem is a computational classic - but firmly grounded in the real world. In this session I'll discuss how at Landmark 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.
Azure Resource Manager In A Serverless WorldEldert Grootenboer
So we have heard about using Infrastructure as Code to deploy our environments and resources, but how do we apply this in a world of Platform as a Service and Serverless? What tooling can we use, and how do we ensure our templates are created correctly?
In this session you will learn tips, best practices and techniques from real customers on using Azure Resource Manager templates to make your journey as smooth as possible. We will see how to get started on creating templates, how to easily move from portal to Infrastructure as Code, and what tools are available to help us with this. And we will dive even deeper, looking into deployment strategies, feature flags and other complex solutions.
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...
Beyond HTTP in ASP.NET Core 3.0 with gRPCSteve Gordon
In this session, Steve will 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!
How to use Cognitive Services to make a chat botHåkan Silfvernagel
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.
Functional Programming in C#Simon Painter
Functional Programming is becoming increasingly popular and relevant with each year that goes by. With so much discussion around languages such as F#, Haskell and Erlang, it can seem as though getting started with Functional programming would mean first learning a whole new syntax...but what if it didn't?
Most .NET developers are familiar with the use of Linq, and basic constructs such as IEnumerable, Func delegates, arrow functions and ternary expressions, but did you know that you can use all of this to implement some of the most powerful patterns and techniques from the world of functional programming?
This talk will demonstrate how, using only familiar features available in out-of-the-box C#, to write Functional code that is:
* More robust
* Easier to read
* Easier to maintain
As well as these benefits, Functional code is a great enabler for the use of concurrency with Async functions and Serverless applications with technologies such as Azure Functions.
This talk might be of interest to anyone looking into moving to a new platform, or in improving the scalability of an existing application, or even just interested in seeing what Functional Programming is all about, but all within the comfort of a familiar language.
We might even attempt the impossible, and explain what a Monad is!
Internationalising your applicationsPete Vickers
Your application is more attractive to non-native English speakers if you can provide your application in more languages.
Devices are available in more or less all countries in the World, so having your application available in more than one language, especially if you are selling it as opposed to giving it away, is a big advantage.
Remember, the Chinese and Indian markets are massive, and have the very cost effective lower price phones and tablets.
In the reviews of some of our apps, some of the reviews have mentioned this.
This session will take you through how to easily add foreign languages in you own applications, using demo applications.
We will show you how to easily manage the heavy lifting by using the latest tools to ease your journey.
Turbocharged: Writing High-Performance C# and .NET CodeSteve Gordon
There are amazing things happening with C# and .NET Core in regards to performance. We have new types such as Span and Memory for working with and parsing in-memory data. We have pipelines for high-performance IO and we have ArrayPool, MemoryPool and OjectPool to help reduce GC allocations. Many more great things are on the horizon in .NET Core 3.0 such as Utf8String and new built-in JSON APIs which add to the performance arsenal. Internally, these have been used by Microsoft teams to optimise .NET Core and ASP.NET Core. Now it's time to apply them to your code!
These features can seem complex, unapproachable and difficult to apply. In this session, Steve will share his journey of learning about and applying these tools when building high-throughput .NET Core worker services. You'll learn about the motivations that led Steve to begin exploring these cool new features and you'll see how they can be applied to production code. This talk is for developers, who like Steve, are ready to begin their journey towards writing faster .NET code, which allocates less.
Azure's Cloud Platform: Building Serverless ApplicationsEldert Grootenboer
Azure provides us with the perfect toolkit of serverless components to build powerful cloud solutions. We have Azure Functions to run our custom code, Logic Apps for our workflows and easy integration, API Management for securing our data and processes, and finally Service Bus for our messaging needs. And all this truly serverless, meaning highly available, dynamic scale and allowing us to focus on logic instead of infrastructure.
In this session you will learn how to combine these services to create powerful scearios, with minimal effort. Come and see how easy it is to get started, while still gaining a lot of possibilities.
Affective Computing – bringing humans and machines closer through emotionsHåkan Silfvernagel
Research have shown that emotions play an integral role in decision making, cognition, perception, learning and more. If we want our computers to be intelligent and be able to interact with us we need to ensure that they are able to recognize, understand and express emotions. This is the basic assumption of the field of Affective Computing. In this talk I will give an overview of Affective computing and how it can be applied in order to make our interaction with machines more suitable to us as humans.
First I will give an introduction to the field starting with established findings from the field of psychology on how we best can measure emotions.
Then I will describe how the field of Affective Computing has transformed from its origin in the 90’s until now when it is an established research field. I will highlight some of the technology enablers that has made Affective Computing a hot topic nowadays and give some examples of API and services that we as developers can use as of today.
In the second part of my talk I will give some examples on application scenarios across various fields (retail, medical, education and social). After that I will be show casing what is in the front line now. I will conclude my presentation with some recommendations on how this affects us as developers going forward.
IoT in your Home? Consequences and CountermeasuresSimon Painter
Getting Started with Unity and AR/VR for the .NET DeveloperDavide Zordan
We all see the cool demos of how augmented and virtual reality are going to be the future of our interaction with devices, but it often feels like there’s a significant barrier to getting started in building these types of apps.
This session is here to help. If you’ve ever thought about developing for Oculus Rift, HTC Vive or the Windows Mixed Reality headsets, but haven’t known where to start, this is the session for you.
At DDD, I will present what I learned building a small game, set in a mysterious dungeon using Unity and the SteamVR plugin. We'll explore how to import assets from the Unity store, how to implement locomotion techniques and interactions using the motion/touch controllers, including some tips for optimising performance and avoid motion sickness.
Come along, there’ll be .NET code, demos and we’ll have some fun looking at how you can get started on your first VR/AR project.
Real Outcomes from AIAndy Cross
Andy Cross, Director of Elastacloud, Microsoft Regional Director, Azure MVP and all round good guy, gives a session on how to successfully build or transform a business using AI technologies.
I'm actually going to show some code, and show you why a "data scientist" is actually a software developer.
Over the last years, Elastacloud have delivered analytics projects to a variety of customers. The greatest challenges around AI are both technical and organisational. The existing landscape of process and strategy doesn't solve these challenges in combination, and the gap between causes friction and the failure of AI projects.
When modelling the outcome of actions that were informed by AI, possibly enacted by AI, the standard risk modelling approaches need to be transformed to include a factor that can change over time to represent the effectiveness of the AI solutions. Given that we should accept errors as part of the AI solution, and that errors are reinforcing of better future decisions, we need to project risk as a decreasing vector over time.
Web Assembly and BlazorHåkan Silfvernagel
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.
Web assembly is also the basis for a Blazor which is a new framework from Microsoft where you can build a web application all in c#. This session will you give an introduction to Blazor as a web application framework.
The History of AI - what can we learn from the past?Håkan Silfvernagel
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.
.Net Configuration is Easy ... Right?Steve Collins
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.
Make serverless more personalPiers Karsenbarg
The serverless movement has become a way for businesses to deploy and run smaller and smaller units of code as part of a much larger system. However, serverless can also be used by individuals as a way of building and hosting mini applications to automate parts of their daily lives all without having to worry about servers, VMs or domain names.
From performing banking tasks, to handling email and even fielding phone calls, serverless applications aren't just for businesses. They can be personal as well.
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".
Let's Talk HTTP in .NET CoreSteve Gordon
In the world of microservices (yes, there's that buzzword again!) and distributed systems, we often find ourselves communicating over HTTP. What seems like a simple requirement can quickly become complicated! Networks aren't reliable and services fail. Dealing with those inevitable facts and avoiding a cascading failure can be quite a challenge. In this talk, Steve will explore how we can build .NET Core applications that make HTTP requests and rely on downstream services, whilst remaining resilient and fault tolerant.
This session will focus on some of the improvements which have been released in .NET Core and ASP.NET Core 2.1, such as IHttpClientFactory and the new, more performant socket-based handler. Steve will identify some HTTP anti-patterns and common mistakes and demonstrate how we can refactor existing code to use the new HttpClientFactory features.
Next, Steve will demonstrate Polly; a fantastic resilience and transient fault handling library which can be used to make your applications less prone to failure. When integrated with the Microsoft HttpClientFactory; wrapping your HTTP calls in retries, timeouts and circuit-breakers has never been easier!
If you're building services which make HTTP calls, then this talk is for you!
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. 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 instrumented application, pipe the data into Azure and demonstrate just how easy it is to create a rich dashboard to monitor the application.
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, we're depending on more remote services and Functions as a Service (FaaS)/Serverless are becoming increasingly common. The very nature of distributed systems mean they're far more prone to failures than similarly-scoped monoliths; this makes predicting or preventing possible failure modes increasingly more difficult. In this talk we'll look at how we can 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 overall resiliency and reliability.
Machine learning in the browser with TensorFlow.jsHåkan Silfvernagel
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 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.
Cloud Recipes For The EnterpriseEldert Grootenboer
Azure offers a wide range of services, with which we can build powerful solutions. But how do we know which services to choose, and how to combine them to create even better architectures? What are the drivers for choosing one service over another? And how do we know when we should combine them?
In this session, you will get a look at real life scenarios, and how these were solved by leveraging the power of Azure. There will be guidance on the various option we have to implement a scenario, and how to choose one over another depending on requirements and customer wishes.
Hacking C#: Development for the Truly LazySimon Painter
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.
Building Smarter Solutions Using Azure And Cognitive ServicesEldert Grootenboer
There's a lot of discussion going on around Artificial Intelligence, and for good reason. AI and Cognitive Services are getting more powerful all the time, and it can be confronting to see all these developments. But how can we leverage this power in our own solutions, using it for making the life of our users and customers easier?
In this session, you will see learn we can get data from the real world, and use this to drive our business, and all this in a serverlss manner. Thanks to Microsoft Cognitive Services it's easy to integrate and work with speech, text, images and videos into our processes. Come and learn how to use this to your own advantage, driving your business forward.