Talks

Instead of fighting "Test Last vs TDD" war we'll discuss in which cases choosing either approach gives the greatest advantage.

Aliaksei will offer an approach to writing integration tests using containerization technology, which allows us to create test environment of almost any degree of complexity. He will tell how this kind of integration tests can become a part of the development process and drastically improve the project quality, drawing on real-life examples.

Windows 10 is here and is progressing at a much faster cadence than in the past. This session is about Windows 10 internals features and how they impact and/or can be used by .NET developers.

Creating offline-first, bandwidth-aware applications to enrich your user experience.

Alexey will talk about domain-driven design: what it is, why we need it, what are its essentials and problems with implementing it.

Implementation of a multi-tenant infrastructure to create SaaS applications in ASP.NET Core.

Unit testing is a vast topic. The industry has accumulated a huge amount of information about it during the past two decades. However, not all unit testing practices yield equal results. It is important for you as a developer to know which practices provide the best return on your efforts.

Anatoly will tell about using the Tarantool DBMS and writing a connector for it. He will also touch on connector optimization and practices of writing quick code, using Span< T> and others.

Vagif will talk about a system based on actor model with built-in scalability: frameworks like Akka let you seamlessly distribute the load between multiple cluster nodes, and actors have location transparency.

You will learn about the full power of SAFE-Stack, a stack which includes powerful F# to JavaScript compiler, library that brings the popular "Elm architecture" to F#, and ASP.NET Core technologies.

This talk will show you how to set up basic build scripts with FAKE and give you an overview about dependency management with Paket.

Running C#/.NET code is something we do all the time. But how does the .exe/.dll file produced by the compiler actually get executed? We'll explore some of what's going on inside the dotnet[core]/Mono runtime, giving some insight into the inner workings of .NET.

In this talk you will discover the work behind the burst compiler done at Unity Technologies: a solution to compile a subset of the C# language to highly optimized native code using the LLVM compiler infrastructure.

This talk consists of interesting micro-optimizations, which were used in .NET Core by the developers and community members, and concentrates on newly minted API to the processor's SIMD instructions, such as SSE and AVX.

Jeff focuses on .NET Generics, on how the CLR creates type objects of generic types and memory and performance issues when using generics with reference types versus value types, and on constraints and the odd behaviors they exhibit.

Jeff will demonstrate the importance of performing asynchronous I/O to build responsive and highly-scalable applications that efficiently use system and application resources.

Konstantin will tell about a case of switching from monolithic to microservice architecture, give some tips and describe several situations in which these practices helped to reach the goal.

This talk covers the following topics:

• what is IQueryProvider in .NET;
• using IQueryProvider to expand IQueryable;
• implementing your own ORM based on IQueryProvider;
• building facade with the help of IQueryProvider.

We'll talk about how to bring legacy code under control using continuous integration and managed deployments, explore creative ways to use common technologies like DNS to create more productive development environments, and talk about why good old Ctrl-Alt-Del might be the secret to unlocking the potential of your legacy codebase.

Evgeny will tell what are the differences between various system metrics, which mistakes in metric collecting do not allow you to see performance issues, which performance issues do Process and PerformanceCounter classes have, and what is the internal design of Performance Counters and how to work with them correctly and effectively.

You'll explore the various extension points provided by the new WinDbg and learn how to use them to improve the user experience by turning the app into a fully featured multi-window debugger with live C#/ClrMD scripting support.

You have to investigate problems live or post-mortem on tens of GB of application memory by browsing complex structures, such as the threadpool or the timer queue and… you start to spend your life typing tons of SOS commands in WinDbg… and you abandon it. Here comes ClrMD to the rescue!

Join us to learn how to write your own tools and WinDbg extensions in C# to automate your future investigations.

Recently, in the new versions of language, ValueTask, task-like types and IValueTaskSource appeared. Most people don't even know they exist, and those who do know don't understand what to do with them. Egor will tell what are these new types, why we might need them and when it is and isn't reasonable to use them.

Learn how you can customize or even completely rewrite the GC in .NET, as well as, why you may ever want to do it.

Maxim will tell about the criteria of good and bad code, how and by what we should measure them. He will review the common tasks and approaches, advantages and disadvantages. In the conclusion he will give recommendations and best practices for web apps design.

We will dig into the new APIs, language features and runtime implementations in IoT and communication scenarios. The goal is showing how these tools give us the opportunity to manage memory efficiently with low complexity in code to improve performance, code maintenance and safety.

Yes, we created our own chat bot platform. In this talk you're going to find out why we did this and what challenges chat bots encounter in a cruel human-centric world. We will also discuss some neat machine learning algorithms which help machines understand the gibberish we humans call language.

You'll learn how to build load-tolerant microservices and perform load testing to make sure they can sustain load.

Performance and stability of a distributed system are inextricably intertwined. We'll discuss how one influences another and how to attain good characteristics mainly by means of architecture, not runtime characteristics of specific components.

Compiler turns methods with yield return and async methods into automata. We'll discuss what exactly they are turned into, some nuances and specific aspects, and examples of tasks where these automata can be used.