And yet, even with all the alternative frameworks, patterns, and cloud services that have become available over the years, even new systems can’t seem to escape their big ball of mud fate.

But, there is another option available – just as challenging, but with a much brighter future. Organizations that can transform their technology, teams, management, and business will be the ones that own that future.

While there’s no “cookie-cutter” approach to this transformation, Udi has some do’s and don’ts that will keep you from going astray.

In this presentation you will learn about the underlying pattern, the OrigoDB implementation and it's shortcomings, what you learned and the resulting implementation of Memstate. You will touch on topics such as async/await, group commit, event storage, nuget versioning, consensus in distributed systems, message ordering, throughput and latency.

In this talk, Luce shares what Xamarin is including Native and Xamarin.Forms for both C# and F#, how to get started creating a simple HelloWorld app from scratch and a more complex example (will involve at least one Azure service including Cognitive Services for facial recognition). Also how to use Visual Studio Team Services for Continuous Integration and some awesome examples of apps written using Xamarin including ones used to save lives!

Luce will take examples from xamarin.com/customers as well as show this demo about how Xamarin was used alongside other technologies to aid with Skin Cancer prediction.

This talk will include slides, demos, code samples, live coding and the audience will walk away feeling like they too can create a mobile app in just a few minutes and carry their work around with them in their pocket or backpack!

The end goal might be breaking your existing ASP.NET monolith into Microservices which run cross-platform on .NET Core, but the first step can be as simple as packaging your whole .Net Framework application as-is into a Docker image and running it as a container.

In this session, Elton will take an existing ASP.NET WebForms application and package it as a Docker image, which can run in a container on Windows Server 2016 and Windows 10. He'll show you how to run the app and a SQL Server database in Docker containers on Windows, and how to use Docker Compose to define the structure of a distributed application. Then he'll iteratively add functionality to the app, making use of the Docker platform to modernize the monolith without a full rebuild.

Elton will take a feature-driven approach and show you how Docker makes it easy to address performance, usability and design issues.

In this talk, you will learn how to build bots as a service combining the power of the Azure Bot Service, Microsoft Bot Framework and some of the Azure Cognitive services.

Building a conversational bot and connecting it to different channels is now an easy task with Azure.

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 the HttpClientFactory and the new more performant socket based handler. Steve will identify some HTTP anti-patterns and common mistakes and demonstrate how we can migrate existing code to use the new HttpClientFactory to work more correctly with HttpClient instances.

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. Now 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!

Now you can build real-time software easily. ASP.NET Core SignalR is a set of libraries that you can use to build real time, scalable, websites and apps.

You can use them in both enterprise and consumer apps, and across platforms. This session covers building an end-to-end real-time app using ASP.NET Core SignalR.

It can get very complicated trying to track and manage the progress of workflows when they are formed of multiple stateless isolated functions.

In this talk, Mark will demonstrate how Durable Functions extends Azure Functions with orchestrators enabling you to manage the state of your workflows, support error handling, retries and simplifying the implementation of more complex patterns such as fan out, and waiting for external events.

While ASP.NET Web API has made the leap to .NET core, there are other options.

This talk will look at some of those options - gRPC is a widely used open source RPC (remote procedure call) framework; GraphQL allows you to build queryable APIs backed by your existing code and data; HATEOAS is a constraint of the REST application architecture, APIs built with this in mind go beyond the simple CRUD approach often used with Web API. Each of these options offers something different, and a single approach may not work everywhere.

During this talk, Dave will explore at each of them and identify where you may want to use each approach.

But, in this presentation, you’ll assume you’d rather focus on delivering business value and show you the hands-on programming techniques to do it all, using NServiceBus and the rest of the Particular Service Platform. Whether you’re running on-premises, on AWS, or on Azure – it all just works. For real.

As the quote from Neal Ford says "Understand one level below your usual abstraction", you will look at why is this important and how can it help you if we apply it to the .NET framework.

This talk will delve into the internals of the recently open-sourced .NET Core Runtime, looking at what happens, when it happens and why. Using freely available diagnostic tools such as PerfView, libraries including ClrMD and even the source code itself!

Along the way you'll examine the Execution Engine, Type Loader, Just-in-Time (JIT) Compiler and the CLR Hosting API, to see how all these components play a part in making a 'Hello World' app possible.

Coding lets her do this, so she wants to share how she got started and how kids and their parents can learn new things together.

Willow will show you Scratch and Hopscotch, then move onto Unity3D and C#, which is what she's learning with her dad now. It's a lot easier than you might think, even with all the squiggly brackets and semi-colons :)

Willow hopes this talk will show you that making real games is something you can do with your kids, and maybe you'll even learn new things yourself along the way.

You may have seen the Twelve-Factor App methodology 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?

Robin will consider the similarities and differences between traditional apps and cloud-native apps. You'll see common security vulnerabilities that affect cloud apps, new vulnerabilities specific to the cloud and tools and techniques to help avoid problems. You'll come away knowing how to be more secure in cloud-native

Unity now s a cutting-edge .net implementation in its own right, and making fascinating moves with new technologies like Burst and High-Performance C#.

This talk will attempt to demystify all these new technologies and the compilers underpinning them.

In this talk, Mete will create a Dialogflow app to get a Google Home device to talk to a container managed by Kubernetes/App Engine.

In the container, he’ll use some of the Machine Learning APIs and BigQuery and see how they can elevate your Google Home app to the next level. He will also integrate with Stackdriver and see how you can get more insights about your app with HTTP tracing and live debugging features of Stackdriver.

About KubeMQ

KubeMQ is a messaging backend, built for efficient migration from .NET/MSMQ environment to Kubernetes.

KubeMQ provides smooth and graduate migration to containers

KubeMQ provides solutions in Kubernetes environment to all .NET communication method

• Supports partial conversion using MSMQ connector
• WCF built-in replacement
• MS-SQL worker bypasses inaccessible SOAP web service
• SignalR built-in replacement
• Easy development and connectivity of proprietary workers

KubeMQ is delivered in a ready to use production setting.

Steve will take you along on the journey of Humanitarian Toolbox and explain how you can help change the world with software.

He will talk about what Blazor is, how to create a Blazor application, some of the things you can do with Blazor, and some of the things that are still in development. At the end of this talk, attendees should know how to get started building web applications using the Blazor framework.

In this Tutorial, you’ll learn how to design, build and deploy .NET services in Kubernetes cluster in Azure. You will also learn how to scale your applications to handle peak traffic.

Prerequisites: - Laptop

Nice to haves: - Azure account if you want to spin up your own Kubernetes cluster in workshop.

The classic approach is not good enough. You expect to be able to have a solution in which we will have instant access to all data, schema-less date structure, scalable throughput and global replication. CosmosDB fulfils all of those requirements.

During this session, you will learn using CosmosDb in your Serverless solutions. Michal will start with a short introduction of this service, and he will present most essential features of CosmosBD. Then you will be able to learn how you can store and query data with this product. You will then try to build your first Serverless solution that will use CosmosDB as a database. Finally, you will play with query optimisation.

Michal would like to show you that you can improve performance and reduce your solution costs by few simple actions.

Please install or organise the following elements:

• Working Azure account where people will be able to deploy Cosmos Db. Of course, it can be a test account (must)
• Visual Studio 2017 version 15.8.x with Functions Tools for Visual Studio extension installed (must)
• Postman (must)
• Cosmos DB Data Migration tool (must)
• Azure Storage Explorer

Unfortunately, without those tools it will be hard for you to take part in this workshop.

Starting from nothing, you're going to build a basic web UI over https://pokeapi.co/ - everything you ever wanted to ever know (or not know) about Pokemon!

The twist here is that we're not going to write any JavaScript by hand at all. With the power of F#, Fable, Elmish & .NET Core you'll build a robust (type safe) high performance web app without ever leaving the comfort of our nice comfy .NET editor.

You'll need recent versions of .NET Core, Node and Yarn installed to take part in this workshop. Basic knowledge of F# syntax will help, but isn't strictly required.

Prerequisites: dotnet SDK 2.0 or higher node.js 6.11 or higher A JS package manager: yarn or npm An F# editor like like VS Code or Atom with Ionide, Visual Studio for Windows or macOS, Emacs with fsharp-mode or Rider If not on Windows: Mono for editor support and package management

This introduction will demonstrate how proper event stream database combined with new C# features like advanced pattern matching can make this journey doable. During the workshop, you will look at a set of simple classes that allow you to build your own mini-framework and use it to build event-driven microservices. You will be using .NET Core and open-source databases like EventStore and RavenDb.

Please ensure that you check and complete the pre-requisites for this tutorial that you can find at http://bit.ly/es- tutorial. You can also just watch the follow the tutorial without writing code, in that case, you won't need to install anything.

The attendees need a laptop with Windows OS installed (a VM running Windows is also fine)

They also need a way to build/run .NET Code (i.e. dotnet CLI, Visual Studio, VS Code, etc)

All the other tools can be downloaded during the tutorial

In this tutorial, you'll be using a toolkit that makes managing and deploying Serverless applications manageable, and it targets multiple cloud providers - AWS, Azure, GCP - even Kubernetes. You'll be using AWS (the free tier should be sufficient).

Please ensure that you have Nodejs and the AWS cli installed.

In this session, Trisha is going to share some lessons she learnt the hard way while managing her career as a Java developer. She's going to tell you secrets that others don’t want to share. And she’ll give you tools for working out what your next steps are.

If nothing else, you’ll get to laugh at the (many) mistakes Trisha made in her search for The Perfect Job.

In this session, you'll learn how to construct an ASP.NET Core app from start to finish. You'll look at building an EF Core model and use it in both Razor Pages with Tag Helpers, and MVC.

You'll also learn how to create middleware, configure the app and its startup. Finally, you will wrap up with security and deployment.

Additionally, the workshop will cover localization and real-time communications in ASP.NET Core.

Prerequisites: Only basic HTML and C# skills required. Intro level SQL a plus.

This hands-on interactive workshop will explore how Istio, an open platform to connect, manage, and secure Microservices supports large scale Microservice deployments on top of Kubernetes.

Attendees will learn how Service Meshes and Istio can enhance communication security, authentication and reliability.

An understanding of Kubernetes is beneficial, but not required.

Prerequisites: Laptop with a modern browser that supports cookies and websockets. Needs to be able to access and use Katacoda.com

Memstate introduces a radically different approach to managing state. Traditional applications pull in some data from the database, translate to internal types and structures, manipulate, translate back and save any changes made to the database. In a Memstate application, the data and code exist together in the same process all defined in whatever high-level .NET language you prefer. The Memstate runtime will provide transparent persistence and strong consistency guarantees and lets you focus on what matters most.

Contents:

• Introduction - A quick introduction to Memstate and an overview of the example application.
• Hello world - Walking through the 10 minute quick start guide
• Custom domain modeling - defining domain model root, entities, domain events, commands and queries
• Test authoring - writing unit and integration tests
• Integrating with the ASP.NET Core web application - calling into
• Memstatefrom the MVC controllers
• Making the application reactive - subscribing to domain events and integrating with SignalR
• Applying different runtime modes: embedded engine, embedded server, external server
• Using different backing stores - EventStore, PostgreSQL
• Running with docker - building a custom docker image and running as a container

System Requirements:
• Any development environment you are comfortable with. VS2017, VS for mac, VS Code
• .NET Core >=2.0 runtime and SDK (Run dotnet --version in your terminal/command prompt to verify)
• Git (Run git --version in your terminal/command prompt to verify)
• Docker (you know what to do now, right?)

Prerequisites:
• Working knowledge of C# including async/await
• An open mind

Start your path from Padawan to Jedi, after this workshop you will be ready to return to work and have code bend to your will.Concurrency, multi-core parallelism, and distributed parallelism are powerful and accessible. These computing concepts promise big impacts on the full spectrum of software applications, including video games, web applications and market analytics suites. Programmers of these products know how to partition computations over large distributed datasets in order to take full advantage of modern hardware and computing environments. These programming skills are not easy to master. This course will introduce technologies and tools available to developers at every level who are interested in achieving high-performance, reliable and maintainable code through functional-style parallelism and concurrency.

You are facing a new era of geographically-distributed, highly-available systems with processor designs that are scaling out in core counts quicker than they are scaling up in core speeds. In keeping up with performance expectations as complexities and dataset grow, scaling out software architectures over these modern computing resources is one of the biggest challenges facing developers today.

This course will introduce you to technologies and tools available to developers at every level who are interested in achieving exceptional performance in applications. You will gain an insight into the best practices necessary to build concurrent and scalable programs in .NET using the functional paradigm, which covers OnPrem and Cloud based applications.

Requirements

.NET Core Sdk 2.0

Mono (on unix/mac)

Visual Studio Code

C# extension

Ionide-fsharp extension

.NET Core Sdk 2.0

Install the Sdk (not the Runtime)

In the page there are also the Step-by-step instructions

Prerequisites:

osx

windows

Check if is installed correctly with dotnet --info should print:

.NET Command Line Tools (2.0.0)

Product Information:

Version: 2.0.0

Mono on unix/mac

For unix/mac, Windows doesnt need it http://www.mono-project.com/download/

Recommended 5.2 , required >= 4.8

the package is the mono-complete, who contains the mono-devel

Check if is installed correctly with mono --version should print:

Mono JIT compiler version 5.2.0.224 (tarball Mon Sep 18 17:33:20 UTC 2017)

.NET Command Line Tools (2.0.0)

Product Information: Version: 2.0.0 Commit SHA-1 hash: cdcd1928c9

Runtime Environment: OS Name: debian OS Version: 9 OS Platform: Linux RID: linux-x64 Base Path: /usr/share/dotnet/sdk/2.0.0/

Visual Studio Code

Install: https://code.visualstudio.com/download

Extensions to install docs:

C# : https://marketplace.visualstudio.com/items?itemName=ms-vscode.csharp

Ionide-fsharp

tps

But you are still deploying to IIS and Windows. You have not left the walled garden, even though Microsoft tore the walls down in the name of OSS. It sure looks scary out there. What replaces IIS? What will I do if I can't run Windows Services using TopShelf? How do you talk to your server if it does not support RDP? What the hell is the bash shell and how the hell do you quit Vim?

If the Linux world is a strange place where you can never imagine deploying your apps, this tutorial is for you.

Ian and Toby are going to take you through the basics of deploying your application to non-Windows environments and running them there. By the end of the tutorial, you will have learnt what the moving pieces are that replace the more familiar world of Windows, why they are not really that scary, and may be much more powerful and how you can use them with your .NET application.

The knowledge gained here will be equally valuable whether you deploy to tin, an EC2 instance, or a Docker container.

Prerequisites: Delegates will need access to a Linux shell, either via WSL, a VM, or dual booting.

Why do you visualise things and how do they help you evolve your work to the next level?

At this Tutorial, you will examine this and try some evolutionary visualisation techniques of your own.