Past Meetup

Writing the world's fastest .NET Serializer / TPL-Dataflow

This Meetup is past

71 people went

Betsson Technologies

Regeringsgatan 28 · Stockholm

How to find us

Use the door phone before 18:00 and take the elevators to the 4th floor

Location image of event venue

Details

It's finally time for a Progressive .NET meetup!

The talks will be in English

The doors open at 17:30 and the first session will start at 18:15. There will be food and drinks.

The entrance door phone will close at 18:00 so please arrive in time (we will leave a phone number on the door for late arrivals).

We have two speakers:

Roger Johansson: Roger has been programming since the tender age of ten. He works as a software architect at Betsson.

He's the founder of OSS project Akka.NET which is a community port of the popular JVM actor framework Akka.

Jon Gyllenswärd: Jon is a Passionate developer, team lead and systems architect with over 17 years of experience in the IT industry. He has a heart for clean code, patterns, and architecture.

When he's not at his daytime job as a consultant with factor10 he's always involved in a startup business or spare time coding project.

------------------------------------------------------------------------------

Talk 1: Writing the worlds fastest .NET serializer

Speaker: Roger Johansson

Abstract: Wire is an ultra-fast serializer for .NET, designed for serializing messages in frameworks like Akka.NET and Project Orleans.
This talk is a dive into the optimizations applied when building and designing Wire.
We will cover concepts such as code generation, efficient allocations, boxing, datastructures and more.

Talk 2: TPL Dataflow

Speaker: Jon Gyllenswärd

Abstract: Today programmers sit on huge computing resources but it's still hard to utilize that power to its full extent. Modern frameworks and tools like async/await and task parallel library makes it easier, but synchronization is still hard. What if there's another way, invented over 40 years ago?

TPL Dataflow Library is a framework that sits on top of task parallel library. It uses asynchronous message passing, a technique that has been around since the early 70:s. The abstractions and declarative programming style it provides makes an excellent ground for creating more human-readable and testable code.

But as always, there are pitfalls and lessons to be learned.

Jon will first be giving a brief overview of the framework before diving into real life code and sharing experiences from a recent implementation of large scale risk calculations that use TPL Dataflow.

There will be code!