Interview and QA with Miguel de Icaza

Building and generating a .NET client for a large API

Source Generators in action

Workshop: Tuning services to deal with latency and errors

Community development and open source in corporate development

Interview. What does it mean to be a speaker on DotNext?

When and how to use the actor model: An introduction to Akka.NET actors

Nullability in C#

Making zero allocation code using the example of optimizing a large library

Workshop: Tuning services to deal with latency and errors (part 2)

What's new in the .NET 5 GC?

DDD, love, F#

Porting a 11-year-old Windows application to Linux

Workshop: Refactoring the domain model

What technologies you should focus on to stay in the profession for a long time

How the JIT compiler works in CoreCLR

Data-oriented design for business applications

Deep down in Blazor authentication and authorization

Workshop: Refactoring the domain model (part 2)

JetBrains Rider build infrastructure

Domain-driven design distilled

Clean architecture in practice

Workshop: Investigating memory leaks in .NET with WinDBG

How our communities work

What’s new in C# 9.0 and beyond

Tips & tricks to improve your .NET build setup with MSBuild

Event sourcing in a long run

Workshop: Investigating memory leaks in .NET with WinDBG (part 2)

Panel debate: Akka or Orleans? Ask their architects!

Patterns of distributed systems in the traditions of Russia's northern indigenous and minority peoples

Workshop: Real-life event sourcing

Mobius — writing your own .NET runtime running on .NET Core

What? Where? When? with DotNetRu

How to easily measure CPU performance and allocation patterns with a few lines of C#

Discovering .NET 5

Workshop: Real-life event sourcing (part 2)

Dates and times: Hard, but not impossible

Building intelligent .NET apps with Azure cognitive services

Running .NET Core performance investigation on Linux

Separation of responsibilities between CPU cores

Поиграем в самое необычное соревнование для программистов. Прямо тут!

Общие библиотеки в корпоративной разработке

Visual Studio 2019 .NET productivity

Raw TCP/IP socket communication

Why databases are crying at the night

Transpiling WebAssembly modules into .NET assemblies

Let's talk about performance analysis

Living in eventually consistent reality

gRPC and its .NET Core implementation

Panel discussion. Books, courses and other hobbies of DotNext speakers

Обзор новых возможностей PVS-Studio для C#

Асинхронная валидация в домене

Versioning, and how it makes our heads hurt

Log in Azure (and without any Cosmos)

Building an educational game with .NET Core and Unity

A long way to hundreds of thousands of RPS

.NET Science Art: How cloud technologies and .NET help to create interactive art exhibits

The AR Cloud is real — building cross-platform AR experiences with Azure Spatial Anchors

Typeclasses in C#

Metrics are fine, but why is it so painful?

Primitives of synchronization and their quantum graph

Примеры интересных багов, обнаруженных с помощью PVS-Studio

Интервью: Использование .NET в банке и борьба с legacy

Релизный цикл одним ботом

Интервью: Как в Контуре адаптируют новичков

Power your .NET Core 3 application with the new generation of diagnostics

Practical F# or functional programming for enterprise

What’s new in .NET Core 3.x and .NET 5 for performance?

Panel discussion. .NET and technologies NOT from Microsoft

The art of code

Dapr for building distributed .NET Core applications

Using SIMD in .NET Core

Интервью: Поговорим о статическом анализаторе кода

Overview of .NET

Platform Wars

Asynchronous streams

Code Review — the art of development

Hot chocolate: An introduction to GraphQL on ASP.Net Core

Splendour and misery of the domain area

Machine learning for C# developers: Introducing ML.NET

Beating CoreCLR's own C++ code with CoreCLR 3.0 intrinsics

What you need to know about .NET Core 3.0 and beyond

Pragmatic memory management

Roslyn: Mastership of state analysis

.NET: Treating the dependences

The Turkish gambit. Business application in half an hour

Bring your ASP.NET Core solutions to Kubernetes in Azure

Fantastic biotechnologies and where to find them

Everything .NET developer wanted to find out about deep learning, but was afraid to ask

From ETW to EventPipe: dig into .NET monitoring pipelines for healthier applications

Create your own serverless PKI with .NET & Azure Key Vault

.NET 5: runtimes

Mutation analysis

The debugging mindset

Metaprogramming for the masses

Nullable reference types — advanced guide

How to collect the entire database into a file and why we use the Akka.NET Streams library

An in-depth look at the new features in C# 8.0 and .NET Core 3.0

Introduction to Event sourcing

Daily performance pitfalls

Writing a .NET Core cross platform profiler in an hour

Distributed tracing in .NET

vvvv — visual programming for .NET

The power of composition

ASP.NET Core 3.0: State of the art

Deserialization vulns: past, present, and future

How to get a grip on your microservices system using a service mesh

Successfully decomposing your monolith

Building your own profiling and diagnosis tools with Event Tracing for Windows

Quantum computing with Q# language

Async programming in .NET: Best practices

ASP.NET Blazor programming 101

Cross-procedural data-flow analysis

Multithreading in .NET: When performance is lacking

The future of .NET desktop development

How I built Rockstar: Parsing esoteric languages with .NET

DDD in microservices: Complexity vs complexity

API gateway made easy with Ocelot and containers

Animals written correctly

What's new in C# 8

Open source software foundations: not totally boring, actually super awesome

Raspberry PI and .NET Core on Linux: the fast track to IoT

Debugging asynchronous scenarios in .NET

Why your architecture is functional and how to deal with it

How to do in-app chaos testing

I don't feel so well… Integrating health checks in your .NET Core solutions

Cross-platform object-oriented interaction between C# and C++

UI architectures: From imperative to functional through MVVM

Yield at me, 'cause I'm awaiting: Async streams in C# 8

Writing a custom, real-world .NET GC

Serverless under the hood

Pitfalls of relational DB access in .NET: rethinking micro-ORMs

Life after business objects

NUKE — a modern build system for C#/.NET

The cost of code

Generics

When to use Test Last, Test First, and TDD

Using Tarantool in .NET projects

.NET Core 2.1: Intrinsics and other micro-optimizations

Help all the humans: Why in the world would you invent your own chat bot platform

So you want to create your own .NET runtime?

Modern web development with SAFE-Stack

Building integration test environment using Docker containers

Implementing IQueryProvider

From monolith to microservices: history and practice

ASP.NET Core multi-tenant architecture: Challenges and solutions

Creating airplane mode proof Xamarin applications

Boosting memory management in interoperability scenarios

Domain-driven design: pragmatic approach

Yield and async-await: internals and uses

Pragmatic unit testing

Make your custom .NET GC — "whys" and "hows"

Instant design

Windows 10 internals for .NET developers

Extend the new WinDbg to build your own dream debugging tool

FAKE + Paket — PowerTools for .NET developers

Behind the burst compiler, converting .NET IL to highly optimized native code by using LLVM

ValueTask: what and why

Building responsive and scalable applications

Life of actors in clusters: why, when and how

System metrics: learning to avoid pitfalls

Surviving under load: fault-tolerant server, smart client

Dodo IS performance architecture

Building your own debugging toolbox with ClrMD

Ctrl-Alt-Del: learning to love legacy code

Apps, algorithms and abstractions: decoding our digital world

Fastware

Building SSO using Identity Server 4.0 (.NET Core 2.0)

Explore the Cosmos (DB) with .NET Core 2.0

How containers work

Debugging as a process

A "bulletproof" pizza store

Distributed transactions are dead, long live distributed transactions!

C# in browser: the new frontier

Bot-Tender: a .NET chatbot walks into a bar

Write your own C# static code analysis tool to drive business rules

Lightweight microservice collaboration using HTTP

Using AOT compilation the right way

Concurrent data structures in .NET: how does it work?

What is going on? Application diagnostics using the cloud

Expression trees for enterprise developers

12-factor apps in .NET Core

Programming quantum computers in .NET using Microsoft Q#

Microservice interaction with HTTP/2

Finding your service boundaries — a practical guide

Pitfalls of high-level cryptography

Advanced .NET debugging techniques from a real world investigation

Building real world production-ready web APIs with .NET Core

Natural language processing in .NET

Scratched metal

ASP.NET Core and Docker — transition difficulties

Reactive Extensions (Rx) 101

Building microservices with .NET Core and Docker

.NET via exceptions

Xamarin: harmfully useful

Astronautics' promising technologies

Let's talk about performance testing

Conquering injections

Serverless compute with .NET based Azure Functions

Self-aware applications: automatic production monitoring

From dependency injection to dependency rejection

The nuances of Mono applications debugging

Functional Programming for C# developers

.NET Core Networking stack and Performance

ASP.NET Core: Preventing attacks 2.0

The Metrix has you…​

Artificial intelligence and neural networks for .NET developers

Approaches for application request throttling

Akka Streams for mere mortals

I have a microservices architecture and I didn't know

Memory model .NET

Debugging and Profiling .NET Core Apps on Linux

TDD upside down

Apache Kafka and reactive microservices with .NET Core

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

Back to the future — building effective cloud services using Orleans

Challenges of Managing CoreFX repo

Runtime code generation techniques in real life scenarios

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

NUKE: Build automation for C# developers

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

Mono + .NET Core = ❤️

Fight: .NET Core vs. Java

Type providers: painless and simple

NServiceBus or MassTransit? .NET ServiceBus frameworks compared

Panel Discussion - Profiling and optimization

Unchain my heart

Back to basics: the mess we've made of our fundamental data types

Under the Hood of the ASP .NET Core Security

Shifting gears for .NET: Moving to containers for .NET developers

Integrating .NET and Java virtual machines

What is .NET Standard?

Containerised ASP.NET Core apps with Docker and Kubernetes

5 commandments of PDB

Automate Your Dumps

HoloLens and Xbox One – new frontier for .Net developers

NuGet beyond Hello World

JetBrains Rider IDE: personal effectiveness skills for .NET-programmers

Authentication and Authorization in ASP.NET Core

ASP.NET Core apps on Linux in production

Democratizing AI on .NET Platform: from chat-bots and cognitive services to deep learning

Building code analysis tools with the .NET Compiler Platform (Roslyn)

The Performance Investigator's Field Guide

The changing state of immutability C#

AOP via .NET

Profiling .NET Core Applications on Linux

Entity Framework Core: Is It Ready Yet?

Learn to cook MSBuild

AvaloniaUI — the first XAML UI-framework with .NET Core Support

Let's talk about memory

Typed or dynamic API? Both!

My awesome journey with Open Source

Interprocess communications: reasons and approaches

Real World REST and Hands-On Hypermedia

Xamarin.Forms — specifics of cross-platform mobile development on C#

The collective responsibility problem

ASP.NET State of the Art

Overview of the new .NET Core and .NET Platform Standard

Performance gone wild: when 100,000 req/sec isn't where you stop…​

WinDbg Superpowers for .NET Developers

Intelligent Chatbots and Cognitive Services

C++ via C#

Multithreading Deep Dive

Stack Overflow — It's all about performance!

Myths about safety of C# code

ETW — Monitor Anything, Anytime, Anywhere

My life with actors: implementing actor model in F#

Stranger Things: Vulnerabilities in .NET Platform

Typescript for C# Programmers

Let's continue to talk about arithmetics

End-to-end JIT

Exceptional Exceptions in .NET

How to create XAML application without Message Bus

Performance tuning Stack Overflow tags

C# Scripting — why and how you can use your C# in places you never thought of before?

Modification of .NET code during runtime

F# for the glory of Data Science

ASP.NET SignalR: Why It's Getting Really Crucial for Web Development

Squeezing the Hardware to Make Performance Juice

Building stuff is a piece of Cake (C# Make)

Date and Time Pitfalls

What's new in C# 7?

ASP.NET State of the Art

Overview of the new .NET Core and .NET Platform Standard

HoloLens and Xbox One — new frontier for .NET developers

Let's talk about microbenchmarking

Integrating Cognitive services to your Xamarin app

Automate design patterns with PostSharp and aspect-oriented programming

Stack Overflow — It's all about performance!

How many lives does .NET have: thoughts on the fate of the beloved platform, Silverlight death, and suchlike

What is new in ASP.NET Core?

Beyond the dynamic prototyping

Rider — new .NET IDE cross-platform by JetBrains: What is it and how does it works?

Setting ReSharper for using it by a team

ASP.NET Core 1.0: Challenges and Opportunities

Talk about dynamic code generation, or “The Dark Side of IL”

Reactive multi-process interaction: JetBrains Rider Framework

PerfView: Measure and Improve Your App's Performance For Free

Code generation for optimization

Game development on Microsoft platform: Technology overview

Let’s talk about arithmetics

Building fast and efficient SPA with ASP.NET Core

Not all the static analyzers are equally useful

.NET Core: Performance Storm

Docker is on duty of .NET development team

How to tame reactive programming in XAML applications

From zero to hero with running your ASP.NET Core 1 application in a Docker container

The C++ and CLR Memory Models

The diagnosing of WCF

Practical examples of microservices' creation

Machine learning on .NET platform

ETW for .NET developers

DDD: Where’s the Value and What’s in It for Me?

Let's continue to talk about arithmetics microoptimizations in .NET applications

Introductory course in bot science

New hardware and API platforms available for UWP

Lightweight cross-platform Web-server based on .NET Framework

Hands-on Experience: What It Means to Design a Domain Model

The Vector in Your CPU: Exploiting SIMD for Superscalar Performance

Entity Framework 7.0

Xamarin.Forms: Strengths and weaknesses

Modern trends in programming languages. .NET and Java ecosystems

Static analysis as hygiene code

Pitfalls of System.Security.Cryptography

How to use DLR

Atomic operations and primitives in .NET

HTTP/2 – What do I need to know?

Structured logging

Native code: Managing unmanageable

.NET 2015: The future is near

.NET Generics under the hood and a JITter bug for dessert

Automating Problem Analysis and Triage

Design and evolution of C# as an example of properties

WinDbg in the hands of .NET Developer

Functional programming in F# in processing of big data and machine learning

What is new in ReSharper 10?

How to move on ASP.NET MVC 6

The Silver Bullet Syndrome

The Courage of Knowing Things (and not being a geek)

Tales of premature optimization

In the wake of BUILD 2015 - .NET platform today and tomorrow

Roslyn API: SyntaxTree vs. CodeDom, SemanticTree vs. Reflection

Let's talk about micro-optimizations for .NET applications

Technical review of .NET News

Roslyn: use in a large project using CodeRush as an example

Code generation: What, How, Why

Universal apps for Windows 10

Extremely simple AppSec .NET practice

Common Scalability Practices that Just Work

Development of enterprise applications using the MVVM approach. Efficiency + Cross-platform

Work with large volumes of data in .NET

ReSharper vs. Roslyn

Writing scalable and sometimes distributed systems with Akka.NET

Round table. Does St. Petersburg need a .NET User Group?

7 habits of highly effective programmers or how to stop debuting and start benefiting

Development for .NET for the Web. No mouse. No UI. Without Windows.

Round table. .NET application performance optimization

Unit testing memory

F# magic for data processing: monads, type providers, and a bit of machine learning

Round table. .NET cross-platform development

Challenges, Pains and Points of Software Development Today

What and how to protect in a .NET application

How to work with external devices and smartphone hardware on Windows Phone

Fast business intelligence with DevExpress Dashboard

What's new in ReSharper 9?

Functional reactive programming in F#

FitNesse in development

ReSharper from the inside: multithreading, data structures, memory traffic

Using Linux as a platform for server-side .NET applications

Entity Framework 7 + Redis/AzureTableStore

C# 6.0 review

Principles of building multi-threaded desktop .NET applications using ReSharper as an example

Code refactoring using PostSharp

Talk about different versions of .NET

What are the disadvantages of DSL, and how to solve the same problems using C# metaprogramming

True story of using SQL Server Change Data Capture

ASP.NET vNext: What it means to you and what it means to Microsoft

How the CLR works and how to make it work differently

Mocks, Stubs & Rock'n'roll: supported tests with AutoFixture

Memory & Performance. Tips & Tricks

Async/await: collecting a rake

Effective use of DLR

Programming at the speed of thought

Memory management and internal CLR mechanisms

Dependency management system in JetBrains .NET products

The main technical news from the BUILD conference - what do the Windows Store and Windows Phone application developers need to know?

Optimization of .NET-applications on the example of ReSharper

Integration of ASP.NET MVC applications for online trading with Yandex.Market

Nitra - framework for creating extensible programming languages

Acceptance Testing Automation for .NET Applications with Fitnesse and TeamCity

Feature Branches vs. Continuous Integration, or How to cross a hedgehog with a snake

Connected Car service on Microsoft stack

“Something with my memory has become …​”

Cross-platform development in C#/.NET with the Xamarin platform

TDD in MVVM-based UI application - recipes from life

Building a WCF service based on the Windows Workflow Foundation