As you have already noticed, the format of the seminar has evolved and adopted a new form: each subsequent seminar is now devoted entirely and entirely to a topic. The fifth was devoted to the Garbage Collector and in 10 hours revealed everything that was possible, leaving behind very specific questions. And its culmination was a report on practical application (a question that interests everyone - "why all this to know ??")

The second question, which, I think, I want to know to everyone, but as a rule, there is no time - this is a matter of working in multi-threaded code and a question of planning and supporting its architecture. These questions are rather complicated, frightening, and often - generally repulsive. And that’s exactly why the usual developer doesn’t go beyond the simplest synchronization constructs. But there are so many interesting things around :)

Not so long ago, I understood one seemingly simple truth: in order to understand how any top-level abstractions work, you need to understand how low-level abstractions work. In other words, to understand how to work with multi-threaded code, you need to know all the basics as a minimum. After that, most top-level abstractions will become clear automatically.

• November 30 in St. Petersburg , from 10:00 to 20:00
• December 7 in Moscow , from 10:00 to 20:00

At the new seminar, which this time concerns not only the .NET platform, as it was before, but covers any platforms (after all, the multithreaded code works on the basis of lower level abstractions) we will cover this topic in as much detail as possible:

Workshop plan

The basics

To begin with, we will look at the base: everything that goes back to the operating system. After all, any top level mechanics work on the basis of the rules of the lower level: the operating system and the processor. This will include the basics of the processor architecture, synchronization primitives and APIs of Windows and Linux operating systems.

BCL, Schedulers, Thread Locals, STA / MTA ...

Having considered these abstractions and having considered the rules for working with them, we will shift to the basic abstractions of the platform itself: BCL, Thread Locals, thread pools and other basics. These abstractions are everywhere, but there will be examples for the .NET platform. We will see the relationship with the operating system, their performance, as well as applicability in various situations.

Platform mechanics

With each new abstraction plus due to the fact that everything will be told side by side: in one day, you will begin to connect all knowledge with each other and we will smoothly switch to different higher-level mechanisms: schedulers, background, multi-threaded code development models.

Lock-free algorithms

up to async / await. And finally, we will look at more advanced multithreading algorithms. We will parse a pair of lock-free algorithms so that each of you can create them yourself.

PLINQ / async-await

Further, having incorporated knowledge of bases, we will start to study libraries of high levels of abstractions: from PLINQ up to async / await, analyzing features of work with each. Here I mean that you are familiar with the libraries themselves and we will delve into each of them at a somewhat more hardcore level.

Of course, we will not be able to uncover the topic of Concurrency in one day: this topic is too extensive and multifaceted. Plus it will harm the quality and memorability. But we will cover a variety of topics and believe me: each of you will learn a lot of new things.

Contacts

• CLRium website # 6
• sunex.development@gmail.com
• +7 (921) 948-16-08