Talks

Memory model .NET

We'll try to tell what memory model is and how it looks like in .NET, what things specification guarantees us, what the platform gives us, what problems can be expected when you step out of your comfort zone (choosing a lock-free direction, etc), how some problems can be revealed by a simple static analysis. Among other things, we'll show that .NET can also happen to have bugs.

Fight: .NET Core vs. Java

We will compare .NET Core and Java runtime environments performance in Linux and Windows OS.

.NET Core Networking stack and Performance

We'll dwell on the architecture of .NET Core networking stack focused on portability and performance, along with general .NET Core BCL performance goals.

NServiceBus or MassTransit? .NET ServiceBus frameworks compared

NServiceBus and MassTransit are similar but have some distinct differences too. What one is most suitable for your application? We'll explore API and features of both.

Challenges of Managing CoreFX repo

CoreFX repo for .NET Core is a large repo with unique challenges to handle bugs, contributions, triage issues, etc. This talk will explore some of the key challenges and how they were handled.

Life, liberty and the pursuit of APIness: the secret to happy code

We'll draw on ideas and insight from user experience, API design, psychology and education to show how you can incorporate discoverability into every layer of your application.

The nuances of Mono applications debugging

We'll talk about Mono applications debugging process in general, consider several debuggers and profilers, along with comparing these solutions with the analogues used to debug classic .NET applications and .NET Core.

Continuous deployment of .NET Core applications and infrastructure in Linux environment

We'll demonstrate the practical experience of organizing the process of .NET Core applications development and deployment on Linux OS, along with setting up the environments from the code. We'll discuss as well the pros and cons of switching to Linux we've discovered for ourselves.

I have a microservices architecture and I didn't know

We’ll share some painful personal experience that resulted from the building of the infrastructure for a company in multiple steps, with limited resources. You'll learn how to rename and leverage the mess you have around to take some concrete functional benefits.

Artificial intelligence and neural networks for .NET developers

This talk is about using artificial intelligence abilities in various .NET projects.

Back to the future — building effective cloud services using Orleans

Offering solutions for typical difficulties in dealing with stateful architecture via a new system building approach using .NET framework Orleans, which gives developers a lot of important advantages through simple intuitive programming model.

Type providers: painless and simple

This talk is about how to use type providers, what problems they can solve, and how to write your own provider to solve your tasks.

Approaches for application request throttling

We`ll discuss the realm of rate limiting (which resources to limit, what the limits should be and where to enforce them).

Conquering injections

This talk is about the problem of .NET apps vulnerability to injection attacks to the languages of different grammars (HTML, JavaScript, URL, SQL, Path, etc.) and how we can deal with it.

ASP.NET Core: Preventing attacks 2.0

This talk covers the differences in security features of various versions of ASP.NET. We'll see how the built-in security features from XSS and CSRF work now, what cryptography abilities are available off the shelf, and how the session management works.

NUKE: Build automation for C# developers

We'll reveal the numerous pros of NUKE, among which are automating the processes of compiling solutions, packing artifacts and deploying applications, providing the IDE features, along with a clean and consistent API across all third-party command-line tools, and so forth.

Apache Kafka and reactive microservices with .NET Core

We'll cover the main principles on which Apache Kafka is built, we'll learn how and when by using it you can solve problems easily and effectively. We'll see how Apache Kafka can be really applied to a system that has a microservice architecture and whose backends are realized on .NET Core and Scala. Also, we'll discuss how by using the reactive approach we'll be able to keep the code simple, reliable and highly productive.

Serverless compute with .NET based Azure Functions

We`ll discuss how to develop Azure Functions using C# and .NET, and how to test, build and deploy to Azure, covering .NET programming details, architecture, internals and hosting.

The Metrix has you...

This talk is about monitoring instruments: how to monitor the app's work after its release, how to collect and present crucial metrics, along with the instruments which can help your app during the diagnostic process.

Self-aware applications: automatic production monitoring

In this talk, we will see how modern Windows applications can self-monitor, self-diagnose, and potentially self-recover without needing an external monitoring agent or a brute-force restarting watchdog.

Patterns for high-performance C#: from algorithm optimization to low-level techniques

We`ll discuss techniques and code patterns for creating a high performance code, how to recognize when optimizations are needed, where the bottlenecks typically are and the code patterns that arise on database engine code optimization.

Mono + .NET Core = ❤️

We'll show you the current state of Mono and its place in the .NET ecosystem and how we reuse and merge code from .NET Core and vice versa. We will look at the latest Mono features and tools such as Embeddinator.

Let's talk about performance testing

This talk is about typical problems of performance tests and possible solutions.

From dependency injection to dependency rejection

This talk examines dependency injection in object-oriented design, and explains how it's not required in functional programming.

Panel Discussion - Profiling and optimization

This open panel is devoted to profiling, optimization, and the state of high-performance .NET applications today. Among other things, we'll talk about how to avoid performance regressions, how to choose which part of the system warrants investments in profiling and optimization, and how to build a system that consists of multiple disparate microservices while maintaining low latency and scalability.

Akka Streams for mere mortals

Processing live streams of data as simple as writing LINQ expressions, without hand-written implementation of individual actors or Reactive Streams interfaces.

Unchain my heart

We'll imagine taking Blockchain further to the next level and discuss what will be waiting for us in a new world where everyone dresses RFID tags and is connected to the Blockchain.

Functional Programming for C# developers

This talk is about functional programming constructions which could be used in C#.

TDD upside down

We'll discuss what's wrong with TDD idea, how TDD works, and share our practical experience.

Runtime code generation techniques in real life scenarios

NET world gained the ability to generate code using the compiler itself via APIs exposed by the Roslyn/CodeAnalisys libraries which many things as parsing, visiting and generating the source code. Practical use-cases and fundamental things for real-life projects will be discussed during the session.

Debugging and Profiling .NET Core Apps on Linux

In this talk you'll learn how to debug and profile .NET Core apps on Linux, using free, low-overhead tools that ship with the OS and the runtime.