CLR Anatomy Workshop and .Net Framework. Roslyn, CoreCLR, CoreFx, Nitra, RyuJIT

    April 03-04 in Moscow and May 29-30 - in St. Petersburg a series of CLRium seminars will be held. This seminar does not have a specific target audience, we are glad to everyone. And beginners, developers, and terry, who have seen the views, architects.

    As people want, we will have more than just technical reports, without water and marketing. We will have many topics, one of which is a real workout for the brain. We will understand from memory dumps how the CLR works and how to interact with it in a way that is not familiar to everyone - directly.

    We'll have:
    • The most in-depth, selective reports on rarely-disclosed issues
    • A whole evening dedicated exclusively to the .Net core. How to work with him “without gloves”, directly, with structures in memory, without reflection.

    What are we proud of:
    • You will not find our material on the Internet: it is completely author
    • The material covers the most interesting areas of .Net, which for some reason are not covered by the material.
    • We do not take extra money from you and therefore we have the cheapest conference and all existing ones. 2,000 rubles in two days - no one offers this. It's like going to the store.

    CLR anatomy

    In this issue, I have been brewing for about a year now and have studied quite closely how the CLR works as data structures to tell you as much as possible about them. Interest in this event should arise at least because this topic is practically not covered on the Internet and the knowledge that you gain will help you look at the platform from a completely new angle. Also, this section of the CLR knowledge is extremely interesting. Microsoft every day presses us with the word "security". Is it so safe, this CLR? Is there so much “magic” there that allows us not to think about security? This is an authoring project and is the result of research with a debugger: what is the structure of .Net objects in memory and what can be done about it.
    • First, we look at the real structure of objects in memory
    • Secondly, we examine the data structures in memory related to the construction of virtual methods, the implementation of interfaces and classes (this was not on CLRium # 1)
    • Next, based on the data received, we will build a proxy type in memory
    • And explore the possibility of making multiple inheritance in .Net
    • We ’ll also try to combine both Java and .Net objects in one object by running both runtimes at the same time (hi, Xamarin)
    • Then, using the experience gained, we will share the .Net object between the processes so that it would simultaneously exist in both worlds.
    • We use the acquired knowledge to answer the question: what standard language constructs lead to performance subsidence and how?
    • Connect the compiler and make our own JIT with blackjack .


    In this topic, we will reveal in full detail the possibilities that confront you when using the open .Net kernel
    • Consider the CLR architecture available to us from source
    • We’ll build the first cross-platform application that runs on our own core
    • Embed in the kernel metrics of kernel performance that the application itself will read
    • Launch an ASP.NET CoreCLR Application
    • [mesh is formed]


    • We will not do an introductory one: on the Internet all the reports are introductory and you saw them
    • We will analyze from simple to complex how the existing rules in the delivery of Roslyn (C # 6 features) are arranged. But consider not a list of how conferences do this, but their source code
    • As soon as we look at them, we look at existing metrics on Roslyn. How they are written, how code metrics are built.
    • Next, we will write not just “count the number of letters“ a ”in all words of the source texts, we will write tuple support for C #:
      var (x,y) = CalcCoords();
      	public (int,int) CalcCoords()
      	   return (0,0);
    • And make the Nemerle match statement
          match (i)
            | 1 => Console.WriteLine(1)
            | 2 => Console.WriteLine(2)
            | x => Console.WriteLine(x)
          match (i)
             | x when (x < 0)  => WriteLine("negative")
             | x when (x > 36) => WriteLine("more than 36")
             | x when (x % 2 == 0)=> WriteLine($"valid even number $x")
             | x                  => WriteLine($"valid odd number $x")
          match (obj)
            | iDisp is IDisposable => iDisp.Dispose()
            | _ => (); 
    • These are very complex examples that you can’t just write in the evening and this is what you want to find on the Internet, but you can’t.


    • We will describe what its use will give us
    • Let's try to run a project on it and measure the performance of the application with and without it on a set of synthetic tests
    • Consider the scenarios when his openness, which is approaching every day, would give us advantages


    Many people say that the openness of the .Net Framework for the community and providing the community with the opportunity to freely make changes is bad and fraught with endless bugs, sloppy code, and an unstable API. Is it so?
    • The results of six months of open .Net Framework CoreFx.
    • Increased productivity from 10x to 1000x in some places
    • Closed bugs
    • The ratio of community code to team code. Net Framework
    • Let's try compiling and disassembling an application written under CoreFx

    Did you miss something?

    If you think we missed something, write in the comments, what else to tell =)

    Read and register


    Also popular now: