03-04 April in Moscow and May 29-30 - a series of CLRium seminars will be held in St. Petersburg. This seminar does not have a specific target audience, we welcome everyone. And beginning to his career, developers, and terry, seen the views of the architects.
As people want, we will have more than technical reports, without water and marketing. We will have a lot of topics, one of which is a real warm-up for the brain. Using memory dumps, we will understand how the CLR works and how to interact with it in a way that is not usual for everyone - directly.
We'll have:
The deepest, selective reports on rarely disclosed issues
An entire evening dedicated exclusively to the .Net core. How to work with it “without gloves”, directly, with structures in memory, without reflection.
')
What we are proud of:
Our material can not be found on the Internet: it is completely author
The material covers the most interesting areas of .Net, which for some reason are not covered with 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 matter, I have been cooking for about a year and I studied quite closely how the CLR works as data structures to tell you about them in as much detail as possible. Interest in this event should arise as a minimum because this topic is practically not covered on the Internet and the knowledge you receive will help you to look at the platform from a completely new angle. Also this section of CLR knowledge is extremely interesting. Microsoft is putting pressure on us every day with the word "security." Is it safe, this CLR? Is there really a lot of “magic” that allows us not to think about security? This is an author's 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 actual structure of objects in memory.
Secondly, we examine in-memory data structures related to building virtual methods, implementing interfaces and classes (this was not on CLRium # 1)
Further, on the basis of the data obtained, we will build a proxy type in memory
And we are exploring the possibility to make multiple inheritance in .Net
Also we will try to combine in one object both Java and .Net objects , launching both runtime at the same time (hello, Xamarin)
After that, using the experience gained, we will share the .Net object between processes so that it simultaneously exists in both worlds.
We use the knowledge gained to answer the question: what standard language constructs lead to a performance drop and how?
Connect the compiler and make your own JIT with blackjack .
CoreCLR
In this topic, we will reveal in detail the possibilities that confront you when using the open .Net core
Consider the CLR architecture available to us from source codes.
Construct the first application designed for cross-platform and running on our own core.
We integrate into the kernel the metrics of the performance of the kernel that the application itself will read
Run an ASP.NET application on CoreCLR core
[mesh is forming]
Roslyn:
We will not do the introductory: on the Internet, all the reports are introductory and you have seen them
We will analyze from simple to complex how the existing rules are arranged in the supply of Roslyn (C # 6 features). But consider not a list, as they do at conferences, but their source code
As soon as we review them, we will review the 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 the words of the source code, we will write support for tuples for C #:
var (x,y) = CalcCoords(); public (int,int) CalcCoords() { return (0,0); }
And make Nemerle match operator
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 easily write for the evening and this is what you want to find on the Internet, but you can’t.
Ryujit
We will describe what will give us its use.
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 scenarios, when his openness, which is approaching every day, would give us advantages
Corefx
Many say that the openness of the .Net Framework for the community and providing the community with opportunities for free editing is bad and endless bugs, sloppy code and unstable API. Is it so?
Results of six months open .Net Framework CoreFx.
Increased performance from 10x to 1000x multiple in some places
Closed bugs
The ratio of community code to the command code. Net Framework
Let's try to compile and parse the application written for CoreFx.
Missed something?
If you think we missed something, write in the comments, what else to tell =)