C# 9 introduced the long-awaited compiler integrated code generation capability. If you've dreamed of getting rid of thousands of lines of code or have always wanted to try metaprogramming, now it's easier than ever!

In this talk, you will learn not only how to write your own source generator from scratch, but also how to provide the user with the necessary configuration flexibility and clear messages about problems. When using source generators, it's difficult to look at the resulting code, debug and troubleshoot, and write tests. This keeps many programmers from using it and in this talk, you will learn how generators cope with these problems.

As metaprogramming isn't new to C#, this talk will also cover how a source generators' approach is different from other technologies such as Fody, PostSharp, T4, and so on. Do they still have unique niches and advantages, or is the future with generators?

Resources

• Source code for the first demo
• Source code for the second demo
• Useful links (existing generators, tutorials, how-to's, etc)

About the Presenter

Andrey Dyatlov, ReSharper Software developer at JetBrains

Andrey started his programming career with SCADA systems and industry equipment. He joined JetBrains 5 years ago, and works on the C# language support in ReSharper/Rider on everything from parser implementation to static analysis and refactorings. He is interested in static program analysis, type theory, and metaprogramming.

• Twitter: https://twitter.com/a_tessenr

Memory leaks, hangs, and crashes are very hard to troubleshoot, especially if they don't happen on your machine.

We will look at techniques, strategies, and tools that you can use to troubleshoot these: WinDbg, DebugDiag, and even Visual Studio.

The session is very demo-heavy.

Resources

• Tutorials and labs on debugging .NET

About the Presenter

Tess Ferrandez-Norlander, Developer, Microsoft

Tess is a developer/data scientist working at Microsoft. Over the past 20 years, she has changed the way we do .NET debugging and has developed a large number of mobile apps. A couple of years ago, she moved into the world of data science and machine learning, working with a lot of the largest companies in Europe and beyond on really tough machine learning problems. She has spoken at lots of conferences around the world on a wide variety of topics including deep .net debugging, UX, web development, and machine learning. You can also find her on Twitter at @TessFerrandez

• Twitter: https://twitter.com/TessFerrandez
• Blog: https://www.tessferrandez.com/

In this session, you'll learn how to write C# code which executes faster and allocates less. This session is packed with practical examples and demos of where the latest high-performance APIs and language features can be applied in your applications.

During this session, we'll apply types such as Span and Memory to efficiently process data and parse strings. We'll examine System.IO.Pipelines, offering high-performance I/O, and we'll utilize ArrayPool to help reduce GC allocations. In .NET Core 3.0, we have new high-performance JSON APIs which we'll also add to our arsenal. Microsoft has made fantastic performance gains to the .NET Core framework – now it's time to apply them to your code!

We'll begin by discussing when and why performance matters in your applications. You'll learn how to measure your code, and use a data-driven approach to focus your optimisations.

These features can seem complicated, unapproachable, and difficult to apply. In this session, Steve introduces high-performance newcomers to the features, showing you how they work, where they can be applied, and how to measure performance improvements in your code.

This talk is for developers, who like Steve, are ready to begin their journey towards writing faster .NET code, which allocates less.

Resources

• High performance .NET

About the Presenter

Steve Gordon, Microsoft MVP, Pluralsight author and Senior .NET Engineer, Elastic

Steve Gordon is a Pluralsight author, Microsoft MVP, and senior engineer based in the UK. He works for Elastic, maintaining their .NET client libraries. Steve is passionate about the community and all things .NET related, having worked with ASP.NET for over 16 years. Steve enjoys sharing his knowledge through his blog, in videos, and by presenting talks at user groups and conferences. Steve is excited to be a part of the .NET community and founded .NET South East, a .NET Meetup group based in Brighton. He enjoys contributing to and maintaining OSS projects. You can find Steve online at his blog www.stevejgordon.co.uk and on Twitter as @Steve Gordon.

• Twitter: https://twitter.com/stevejgordon
• Blog: https://www.stevejgordon.co.uk

Traditionally, when building SPA applications it feels a lot like we are looking at the moon. On the light side, we have the shiny and pretty UI, which everyone knows and loves. On the dark side, there is the complicated server-side logic behind the scenes we need to manage.

Luckily, there has been much progress towards making our lives as developers a bit easier. This is done by allowing us to concentrate on writing code, instead of causing us headaches from all the aspects around hosting, deployment, and management.

In this demo-rich session, we are going to build a real-time stock monitoring system using a serverless React App backed by the power of various Azure features. You will learn how to process documents from Azure Cosmos DB Change Feed, and then broadcast this newly received data to our client, all by using out-of-the-box Azure Functions bindings for Cosmos DB and SignalR.

Resources

• Demo code

About the Presenter

Olena Borzenko, Senior Backend Engineer, Durstexpress

Olena is a senior backend engineer at Durstexpress from Berlin in Germany. She has previously worked in a service company based in Ukraine and took a part in the creation of various products from small startups and B2B applications to enterprise platforms. She is passionate about new technologies, clean code, and best practices. In her free time, when she’s not spending it on hobbies, she likes to build demos around real-life use cases, share knowledge with others, and learn about the experience of others.

• Twitter: https://twitter.com/borzenko_lena

With an increasing need for scalability and performance dictated by the modern web, it is becoming harder and harder to choose an API paradigm that is suitable for service to service communication. While the classical models still work and have their own merits, some of them rely heavily on documentation, extensive coordination between teams, or code-sharing. We use shared libraries, and over time our projects become intertwined with dependencies. In these cases, we need something to untangle those and reduce coupling. Welcome to gRPC.

gRPC has been around for a while and .NET Core 3.0 welcomes it as a first-class citizen. It is contract-based, performant with smaller response/request bodies, perfect for polyglot environments, and supports different models – from client-server to bi-directional streaming out of the box.

In this session, we will look at how to use gRPC and its 4 models and what are the benefits and downsides of using gRPC compared to the traditional models.

About the Presenter

Irina Scurtu, Microsoft MVP, Software Architect, Endava

Microsoft MVP for Developer Technologies, Software Architect, and Microsoft Certified Trainer, always looking for the latest trends and best practices in architecture, .NET, and the world around it. Irina has more than 1000 hours of experience delivering training, workshops, and presentations, and is passionate about .NET and the world around it.

She is the founder of DotNet Iasi User Group, where she tries to gather people that are willing to share their knowledge with others, and from time to time publishes articles on her blog: http://irina.codes

• Twitter: https://twitter.com/irina_scurtu
• Blog: https://irina.codes

Blazor and GraphQL combined will revolutionize how we build rich SPA applications with pure .NET. Blazor, for the first time in years, gives .NET developers the ability to develop applications that run in the browser. This allows us to use our knowledge that we acquired in the backend or with desktop applications on the web.

GraphQL on the other hand changed how we work with data fetching. With GraphQL, the frontend developer defines how the interface between the frontend and the backend looks. We no longer have friction between backend and frontend developers and are able to iterate much faster.

Let us explore how we can put those together and change how we design components by binding them to GraphQL fragments. With GraphQL, the data becomes front and center and drives our application.

After having a fundamental understanding of how GraphQL improves our data fetching needs in web applications, we will move on and build a nice real-time application with Blazor and GraphQL. Let’s build a truly engaging next gen application and push Blazor to the limit!

Resources

• Demo code
• Slides used during presentation

About the Presenter

Michael Staib, Developer, ChilliCream

Michael is a Microsoft MVP and the author of the Hot Chocolate project (https://github.com/ChilliCream/hotchocolate), a platform for building GraphQL servers and clients in .NET. For the last three years, this open-source project has been his main focus.

Apart from his work in the open-source community, Michael works as a consultant to help companies to move to GraphQL. You can read about the Hot Chocolate project on his blog https://chillicream.com/blog/.

• Twitter: https://twitter.com/michael_staib
• Blog: https://chillicream.com/blog/

Databases are like languages—it's very useful to know more than one. NoSQL databases promise better performance, scaling, lower cost of ownership, and flexibility for many use cases. With recent advances in NoSQL, including ACID transactions, SQL queries, scopes, collections, and more, making the jump to NoSQL is becoming more straightforward. In this session, I will demonstrate my work-in-progress open source tool to automatically migrate SQL Server's AdventureWorks sample (including tables, data, indexes, users, and even queries) over to a NoSQL database (Couchbase). I'll discuss the trade-offs, benefits, pros and cons. After this short session, you'll have taken a huge leap to learning a new technology.

Resources

• Example code

About the Presenter

Matthew Groves, Microsoft MVP, Couchbase Developer Advocate

Matthew D. Groves is a guy who loves to code. It doesn't matter if it's C#, jQuery, or PHP—he'll submit pull requests for anything. He has been coding professionally ever since he wrote a QuickBASIC point-of-sale app for his parent's pizza shop back in the 90s. He currently works as a Developer Advocate for Couchbase. His free time is spent with his family, watching the Reds, and getting involved in the developer community. He is the author of AOP in .NET (published by Manning), a Pluralsight author, and a Microsoft MVP.

• Twitter: https://twitter.com/mgroves
• Blog: https://crosscuttingconcerns.com

There are a lot of cool and usable new features being added to C#. However, way too many of us are too busy building stuff, and fixing/creating bugs, to have the time to sit down and take it all in. So why not let Chris Klug walk you through his top 10 new features that have been added in C# version 6 to 9?

Sure, C# has gotten a LOT more than 10 new things since version 6. But if you are a busy developer, like most of us are, getting an introduction to the top 10 ones in just an hour, could be a great start. In this talk, Chris will show and explain, his personal top-10 favorite features that have been added to C# in the last few years. Everything from awesome time savers and stability contributors, to syntax changes that allows your code to be denser and easier to read.

About the Presenter

Chris Klug, Developer, Active Solution

Chris Klug is a developer badass-as-a-service that either creates or solves problems depending on who you ask. He loves creating and building things. Whether it be a new application, a new kitchen, or a new RC helicopter, you will see him building things all the time. Most of the time, that means writing code and solving problems for clients at a company called Active Solution in Stockholm, though. Except for the many days he spends at conferences and user groups, talking about doing things he is passionate about, and for the days he goes mountain biking, IPSC shooting, kiteboarding, or RC helicopter flying.

For the last 15-something years, he has been solving problems for customers, and loving it. But if he gets to choose, he'll go to the beach and kitesurf every day!

• Twitter: https://twitter.com/ZeroKoll
• Blog: https://fearofoblivion.com/

Those who develop with .NET probably do so with C#. But F#, in particular, has great potential to make daily work easier. Everything that C# can do can also be done with F#, and often in a more lightweight and less error-prone way. If you want to see where the differences are and why F# is a good programming language for normal software development, come to this session! And don't worry, the talk is free of functional programming jargon – I promise!

Resources

• [Slides used in this presentation(https://www.dropbox.com/s/203mmhxldm71ryf/Why every day as a developer would be easier with F%23.pdf?dl=1)

About the Presenter

Urs Enzler, Software Architect, Calitime AG

Urs Enzler is a .NET developer since .NET was born. As a software architect, he builds flexible, reliable, and maintainable software together with his team.

• Twitter: https://twitter.com/ursenzler
• Blog: https://www.planetgeek.ch/

Packaging software into containers gives your code everything needed to run with consistency from your laptop into production. But how do you run containers at scale in the cloud? In this session, learn how to run containerized .NET applications in production on AWS. We show you how to run containers on Kubernetes with Amazon Elastic Kubernetes Service (Amazon EKS). We also demonstrate the benefits of running .NET 5 Linux containers serverlessly with AWS Fargate. We cover core concepts and use demos to help you feel comfortable getting started with building and deploying .NET containerized applications on AWS.

About the Presenter

Martin Beeby, Principal .NET Advocate, AWS

As a Principal advocate for Amazon Web Services, Martin travels the world showcasing the transformational capabilities of AWS. In his career, Martin has spoken at over 250 events and meetups as well as producing, blogs, tutorials and broadcasts.

Martin has been developing applications since he was 16 and over the past 20 years has worked on projects with many major companies and brands.

His primary focus is on .NET applications and has worked as a C# and VB developer since 2001.

Prior to joining AWS, Martin worked for Oracle and Microsoft as a developer evangelist and software development engineer.

• Twitter: https://twitter.com/thebeebs

This will be a talk on strategies we have employed to "rescue" legacy code, and how you prevent your system from becoming the Big Ball of Mud. It's not code specific, but it is aimed at developers.

There is an almost inevitable slide into complexity that happens to most code bases. As legacy code is more ubiquitous than green fields development, I believe that we spend too little time figuring out how to get better at maintaining existing systems.

Of course, tools like refactor make the code changes much easier, but this is mostly a talk about a mindset of keeping code clean. It is also an appeal to developers to spend more time on design - more thinking and less typing.

I co-founded my software company 34 years ago, so we have plenty of legacy code! I will share some techniques that have worked well for my teams, in our ongoing effort to stop the slide into the mud!

About the Presenter

Lorraine Steyn, Simplifier-in-chief, KRS

Lorraine founded the software development company Khanyisa Real Systems (KRS) in 1987. The company now employs around 60 technical staff, and has delivered large bespoke projects for hundreds of clients. Lorraine is a hands-on CEO who spends 3-4 days a week working on production code with her teams, mentoring, assisting with design, and driving quality and learning.

Lorraine has presented on such varied topics as Domain-Driven-Design, compassionate leadership, clean code and refactoring, women in tech, and many Agile topics dear to her heart (often based in XP practices).

• Twitter: https://twitter.com/lor_krs
• Blog: https://beingrealblog.wordpress.com/

System.NullReferenceException: 'Object reference not set to an instance of an object.' I used to read this message almost every day.

Null references, also referred to as the "billion-dollar mistake" in that context, are also a great mechanism to express optionality and the unavailability of a certain resource. There are great tools to help us deal with ... utilize null pointers. IDEs and Analyzers have introduced diagnostics that warn us at compile time about potential trouble at runtime.

And recently the magnificent C# 8.0 has brought us nullable reference types: a language feature that lets us annotate our API to clearly communicate the design intent of nullability. So let's explore this (including the accompanying nullable attributes of the BCL) and other keywords and operators based on null.

As a side effect, we will learn about the fundamental difference between nullable reference types and nullable value types in .NET.

Additionally, we will discover an alternative to null while still retaining the semantics of "nothing" - Spoiler: the null object pattern

Resources

• Slides and Try.NET notebook

About the Presenter

Stefan Pölz, Clean C# Coder – Test-driven .NET Developer

My passion is to practice Clean Code and test-driven development in order to build maintainable software in an ever-evolving team, supported by tools from the .NET Ecosystem. I love to attend and speak at public developer events and author open-source projects, complementing my expertise in professional software development.

• Twitter: https://twitter.com/0x_F0

The async and await keywords have been a part of the C# programming language for a long time. Despite that, they still hide traps that not only beginners but also more experienced developers occasionally fall into.

In this talk, I will present some of the most common mistakes we can make when writing asynchronous code and show ways to avoid them.

Resources

• Sample code

About the Presenter

Damir Arh, Microsoft MVP, Razum d.o.o.

Damir Arh has many years of experience with software development and maintenance; from complex enterprise software projects to modern consumer-oriented mobile applications. Although he has worked with a wide spectrum of different languages, his favorite language remains C#. In his drive towards better development processes, he is a proponent of test-driven development, continuous integration, and continuous deployment. He shares his knowledge by speaking at local user groups and conferences, blogging, and writing articles. He has received the prestigious Microsoft MVP award for developer technologies 9 times in a row.

• Twitter: https://twitter.com/DamirArh/
• Blog: https://www.damirscorner.com/

Debugging issues within applications is challenging! In this session, I'll show how debugging works and demonstrate the many ways that JetBrains Rider enables you to find those annoying issues. I'll explain the run/debug configurations, what application breakpoints are and to make them conditional, or how breakpoints can be skipped altogether. While we are in a breakpoint, we'll explore the many ways to navigate through the code but skipping lines, running to line, jumping in, and using methods. Once we find an issue, we'll look at how we can inspect the values in memory and even change them.

At the end of the session, you'll walk away with a lot of knowledge to help you find those annoying issues in your applications. As a bonus, you'll walk away with a little debugging secret.

Resources

• Master debugging
• Joe's stream

About the Presenter

Joseph Guadagno, Director, Technology at Quicken Loans, Organizer of Desert Code Camp, "Microsoft Developer Services" MVP, Telerik Ninja

Joe Guadagno is a Director of Engineering at Quicken Loans, the nation’s largest mortgage lender, which is based in Detroit, Michigan. He has been writing software for over 20 years and has been an active member of the .NET community, serving as a Microsoft MVP in .NET for over 10 years. At Quicken Loans, I lead 3 software development teams building and modernizing our internal services. He has spoken through the United States and at international events on topics ranging from Microsoft .NET, Microsoft Azure, Ionic, Bootstrap, and many others. You can see the complete list at https://www.josephguadagno.net/presentations. When not sitting at a computer Joe loves to hang out with his family and play games. When not playing games with the family, Joe is checking out the latest in Home Automation. You can connect with Joe on Twitter at @Joseph Guadagno, Facebook at JosephGuadagnoNet, and on his blog at https://www.josephguadagno.net.

• Twitter: https://www.twitter.com/jguadagno
• Blog: https://www.josephguadagno.net