.net .net core Azure JetBrains Software Architecture Web Web API
Maarten Balliauw loves building web and cloud apps. His main interests are in .NET web technologies, C#, Microsoft Azure and application performance. He is Developer Advocate at JetBrains. He's an ASP Insider and former Microsoft MVP. Maarten is a frequent speaker at various national and international events and organizes Azure User Group events in Belgium. In his free time, he brews his own beer. Maarten's blog can be found at http://blog.maartenballiauw.be.
The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated. In this talk, we’ll go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), ClrMD and more!
Speaking from experience building a SaaS: users are insane. If you are lucky, they use your service, but in reality, they probably abuse. Crazy usage patterns resulting in more requests than expected, request bursts when users come back to the office after the weekend, and more! These all pose a potential threat to the health of our web application and may impact other users or the service as a whole. Ideally, we can apply some filtering at the front door: limit the number of requests over a given timespan, limiting bandwidth, ...
In this talk, we’ll explore the simple yet complex realm of rate limiting. We’ll go over how to decide on which resources to limit, what the limits should be and where to enforce these limits – in our app, on the server, using a reverse proxy like Nginx or even an external service like CloudFlare or Azure API management. The takeaway? Know when and where to enforce rate limits so you can have both a happy application as well as happy customers.
With .NET Core, an explosion of .NET IDE's happened! There's good old Visual Studio, but also VS Code and JetBrains Rider. In this talk, we'll dive into the latter. We'll explore navigation, automatic inspections and quick fixes, code generation, built-in tooling like version control integration and local history and look at the special scenario's the debugger has to offer, like conditional breakpoints. Come to this session to learn about this new (and fast!) kid on the block and learn plenty of tips & tricks to enhance your development productivity.
We browse the Internet. We host our applications on a server or a cloud that is hooked up with a nice domain name. That’s all there is to know about DNS, right? This talk is a refresher about how DNS works. How we can use it and how it can affect availability of our applications. How we can use it as a means of configuring our application components. How this old geezer protocol is a resilient, distributed system that is used by every Internet user in the world. How we can use it for things that it wasn’t built for. Come join me on this journey through the innards of the web!
In this session, we’ll see that Redis is more than just an in-memory cache system we can use in our applications. Let’s explore what Redis is, what the different data types are and why we should care. And once we grasp how Redis stores its stuff, we’ll delve into how we can use it to its fullest extent: searching the key-value store, transactions, pub/sub support and scripting.
Everybody is consuming NuGet packages these days. It’s easy, right? Many are creating their own packages. Not too hard either!
In this talk, we will look beyond the typical NuGet scenario's. We'll cover versioning, dotnet new, and create .NET CLI tools. We'll use the NuGet client API to fetch data from NuGet. And build an application plugin system based on NuGet packages. And what's cool with the NuGet server API?
Do all of these have practical use? As a matter of fact, some do! Come and find out!
After a quick refresher on .NET memory management, we will switch to continuous demo mode and use ClrMD (Microsoft.Diagnostics.Runtime) to explore the managed heap and navigate the various CLR data structures. Let's try and find string duplicates, look at the state of various objects and perhaps even investigate a memory leak?
This talk will give you a better understanding of how the .NET CLR manages memory for our applications, some of its inner workings, as well as the data we can see in the debugger or in a profiler. By, essentially, writing one ourselves. Let's geek out!
Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider. We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!
31 May 2018 - 2 Jun 2018