Overview of the most interesting reports DotNext 2018: version of EastBanc Technologies

    Hi, habrovchane!

    We returned from a conference for .NET developers DotNext and honestly share our impressions about the most memorable reports. We hope our review will be useful to those who will watch video recordings of performances.

    A part of the presentations was published on the conference website, so we added some reviews with links to them.

    Day 1

    Using Tarantool in .NET-projects - Anatoly Popov ( presentation )

    The report began with an overview of the evolution of SQL databases -> NoSQL -> NewSQL, their pros and cons. Anatoly told why, in fact, there was a need for NewSQL - an attempt to cross the performance of NoSQL and the language of SQL queries, for which a billion useful tools are available.

    The following feature was mentioned about Tarantool - records are stored in the form of tuples of arbitrary length. LSM-trees are used under the hood of the Tarantool.

    Anatoly told about the main part of the report about the struggle for performance in the implementation of the Tarantool driver for .NET. New abstractions Readonly Span and the pool IMemoryOwner went into action. The 200k RPS taken by the Golang driver is taken as a standard, and so far it has been possible to achieve 1/3 of the result. The speaker assured that he will gradually improve the performance, but the specific future plans and prospects remained in the fog.

    Optimization Inside .NET Core - Egor Bogatov

    Egor overlaid with his pertinent humor his story about mono and ryuJIT guts, unlike the Unity Mutel, who was rather sleepy to listen to.

    Egor covered the topic of auto-vectorisation of calculations in mono, also told about the SSE-AVX-instructions, which are now available directly from C #.

    Looking into the future, he told that in .Net Core 3 we are waiting for tier compilation, i.e. a separate heavy jit like server in Java will appear in runtime. In ryuJIT, new loop unrolling and escape analysis optimizations are expected (the last one is sawn by the student, may the github help him).

    Our comment: today remains an impressive start for even greater performance gains of the platform, since many important optimizations from the world of Java and classical static compilers are still not used in .Net.

    Modern web development with SAFE-Stack - Steffen Forkmann

    Stefan is an ardent apologist for the F # language. In the report, he shared the experience of web development, fully built on functional canons. Here you will find both Functional MVC Web Framework (Saturn), and Fable for translating F # to JS, and Elm-like UI, fairly seasoned with really nice and very good phrases. The report is generally not bad and confirms the supernatural abilities of alternative religions.

    Creating airplane mode proof Xamarin applications - Gerald Versluis ( presentation )

    In terms of presentation, the report is very similar to the report about the SAFE-Stack and looks like a Smack transfer: first we put the Essentials component in the dashboard with access to the Internet, then skip the REST API through Refit, cool the data in the Akavache cache, sprinkle it with Polly for smart error handling of network requests. Not without Dutch self-irony, because the application now and then randomly crashed in the simulator.

    ASP.NET Core Multi-Tenant Architecture: Challenges and solutions - Halil İbrahim Kalkan ( presentation )

    The report describes all the main features of the architecture of multi-tenant applications.

    The basic idea is that when a company develops SAAS applications, it wants to use the infrastructure to its fullest. Therefore, it has several clients on one server so that the server does not stand idle. This raises a problem related to the fact that all the data of different customers are located in one boiler. The report focuses on solutions that enable reliable access to this data.

    An excellent report, in which everything is laid out on the shelves. Simple and understandable examples without unnecessary details - they are written very elegantly, using modern patterns and approaches. We looked with pleasure.

    Domain-driven design: a recipe for pragmatics - Alexey Merson ( presentation )

    An excellent report on the basic concepts of DDD. What book to read first: “blue” or “red”? How does the whole team speak the same language? Is it possible to use Cyrillic naming in C # programs? How to finally stop being afraid of the Separated Interface and make the domain code not dependent on the rest of the application? All these moments with examples covered in this report.

    Alexey emphasizes the importance of language (single language) for the implementation of a single Bounded Context. He told how you can choose the size of the Bounded Context and what types of Subdomain can be. Also in the report it was said that one Bounded Context is equal to one microservice - this correlates well with our experience in implementing projects.

    It was interesting to hear about the essence of the onion architecture and the advantages compared to the three-layer / four-layer architecture.

    The report is ideal for those who are new to DDD and want to transfer their monoliths to microservices, and for those who are starting to develop microservice solutions.

    Day 2

    Pragmatic unit testing - Vladimir Khorikov ( presentation )

    One of the best reports and speakers in our opinion.

    Vladimir scrutinized what was the true purpose of tests for a project, which metrics determine the quality of tests, how different types of testing correspond to these metrics. It is impossible not to agree with all thoughts, so must see.

    Horikov recorded many courses at Pluralsight - look for him there. He also has a good blog .

    Instant design - Maxim Arshinov ( presentation )

    Continuing the report of Merson about DDD, Maxim talked about the transition from the classical code splitting by layers to the onion architecture, refactoring the user email update method throughout the entire report. The result was a pipeline of decorators (hello, yegor256) in CQRS-style with the most strict typing of DTO (hello, FSharpForFunAndProfit).

    At the exit, we received a ready-made guide to action, which can be used in the project to get the same elegant code as in Max.

    In general, the report is extremely saturated with useful ideas. Maxim's experience in teaching was positively reflected in his skill level as a speaker - it was just nice to listen to the presentation.

    Behind the burst compiler, converting .NET to the highly optimized native code by LLVM - Alexandre Mutel

    Apparently, Unity bared its teeth on A-class games, and therefore igrodels need performance much closer to C ++. Mutel told how they achieve good results by allocating a subset of the C # language (HPC #), in which there are ready-made structures for efficient work with memory without GC and there are some familiar language constructs.

    The idea is to apply this subset only for the most costly methods, so that in other places the hands will be untied, as always (as far as is permissible in game-devise). To compile HPC #, a new AOST / JIT burst compiler is being developed. Burst in comparison with ryuJIT already gives out 10x on some synthetic tests.

    In the examples shown, the generated assembler shows how brainy the compiler is. And the solution is one and does not surprise anyone - the IL code is fed to the LLVM. Also for mathematics written intrinsiki using a third-party high-performance library.

    The report is difficult to understand, the speaker is too harsh.

    Life of actors in a cluster: why, when and how - Vagif Abilov ( presentation )

    The report revealed that half of the audience is sitting on F #. This is perhaps the most pleasant of what was in this report. The performance ended with a live chant about the split brain in the cluster. It is nice.

    How to survive under load: fault-tolerant server, smart client - Igor Lukanin ( presentation )

    Igor told us about the kitchen of the hayload in the projects of “Kontur”. I was surprised by the fact that the company uses a “balancer” on the client: the API sends information about the cluster node load and 429 statuses, depending on which client understands how to distribute requests. He also showed the resource utilization metrics and how to determine if everything is good or bad. He told how to quote requests by timeout and by client, and also why the queue is better processed in the LIFO order.

    The microphone was owned by an experienced speaker, it was comfortable to listen to Igor.

    Performance Architecture Dodo IS - George Field ( presentation )

    At first, the report seemed rather dull: the uncertain pace of the story, boring slides with lists of technologies, well-known definitions. At some point, a suspicion arose: the speaker will soon say that only a queue at the entrance is needed. But it was not so easy.

    If we briefly describe the report, we can say that it was devoted to the capabilities of the Polly library , such patterns as Retry Policy, Bulkhead Isolation, Fallback, and spiced up with excellent examples from the life of Dodo Pizza.

    The trend of recent years is to use asynchrony everywhere. But this trend has an unobvious effect - this leads to the fact that server resources are “clogged up”. Previously, everything was limited to a thread pool (thread pool). The web server had a fixed pool of threads that processed incoming requests by performing synchronous operations. This limited the load on the server. Each thread was released and accepted for processing the next request, when all the work was really finished.

    Nowadays, developers often write asynchronous code without thinking about the consequences. As a result, the web server threads, starting the next asynchronous task, are released and proceed to the processing of new and new requests. Over time, the number of competitive asynchronous operations grows, and the web server continues to accept more and more new requests for processing.

    The author in his report just tells what competition is (concurrency) and why it should be limited. By the way, this and other problems of load and fault tolerance management are solved by the Polly library.

    In general, even if you do not develop high-load services, still read this report.

    Building responsive and scalable applications - Jeffrey Richter ( presentation )

    This is a rather old report by Jeffrey Richter. It could be found on the Internet for at least a year now, and the topic is no claim to novelty. But damn, this is Jeffrey Richter! We could not but listen to the author of the book, which is considered to be the bible of any C # developer. Old Jeffrey was a pleasant person and a good speaker. We just had a great time.

    Also popular now: