Session list

This is only part of our agenda. We will prepare 33 tecnical sessions for our participants.

  • .NET 6 features that they didn’t tell you about

    .NET 6 and related frameworks came with plethora of new big features. But there’s also fair amount of small, but still very interesting, features, that you might even use more often than the big features. In this session I’ll try to uncover these for you.

  • ASP.NET Basics for Experts

    People love to stay in their comfort zone and do what they’ve always done. But what if you could take your web applications to the next level just by getting the fundamentals right?

    In this .NET 6 demo-rich session, I will show you how to make your applications more testable, maintainable and resilient.
    Whether you are working with a monolith or a vast distributed application, the areas we’ll cover will be applicable.
    Join me and learn about the following topics and more!

    – Minimal APIs, top-level statements and good design practise
    – Dependency injection and inversion of control
    – HTTP clients and policies
    – Resiliency and circuit breakers with Polly
    – Discovery clients with Steeltoe OSS

  • Azure Spot instances as your secret weapon

    Almost everyone knows virtual machines in Azure. But with a little effort, it is possible to modify the application and use Spot instances, which can be an interesting financial alternative. In this session we will look at what Spot instances are, how they differ from common VMs and how to use them effectively.

  • Build Automation Revolution with NUKE

    Solid and scalable CI/CD pipelines are an essential pillar for being competitive and creating a great product. But why are most of us a little afraid of touching YAML files and don’t even dare to look at build scripts? Much of this is because C# developers are spoiled with a great language and smart IDEs, and they don’t like missing their buddy for code-completion, ease of debugging, refactorings, and code formatting. NUKE brings your build automation to an even level with every other .NET project. How? It’s a regular console application allowing all the OOP goodness! Besides, it solves many common problems in build automation, like parameter injection, path separator abstraction, access to solution and project models, and build step sharing across repositories. To conclude your build revolution, NUKE can generate CI configurations (YAML, etc.) that automatically parallelize build steps on multiple agents to optimize throughput!

    Come to this session to make your build scripts loveable!

  • Building a software product line platform

    One of the least-known engineering practices in the software development industry outside of embedded systems is software product line engineering. That’s because many companies create multiple, disparate products that result in overly-complex management, more bugs, and more difficult maintenance, when instead they could have created a platform (product line) for their software products. Creating a product line results in an architecture where code is more reusable than with any other architecture.

    A lot of software can benefit from being in a software product line. The benefits result in faster time to market, lower maintenance, fewer bugs, and makes inherit complexity more manageable. In this talk, you’ll learn how to architect and build a product platform by examining the JetBrains Platform SDK as well as some other industry notable product lines.

  • Creating a quantum algorithm using Microsoft Q#

    In the last couple of years, there has been a lot of talk about quantum computing. Last year, Microsoft has released their preview of Azure Quantum. So today, you cannot only write quantum programs on a simulated environment with Q# and .NET, but you can also write Q# and target a physical quantum computer on Azure Quantum.
    In this session, I will guide you through the implementation of an existing quantum algorithm, step by step, while I explain all the details. This will be a very technical and code-heavy session.

  • Deep Dive into Azure Service Bus Messaging

    Messaging is the backbone of many systems. Not all messaging platforms are born the same. Some are less sophisticated, some are more. Some are so advanced it’s like taking a racing car for a spin; powerful and thrilling at the same time. Say hello to Azure Service Bus.

    In this session, you will learn what Azure Service Bus messaging has to offer and why it could become the next cloud service you want to use. Unleash the power of Azure Service Bus in ways you’ve never seen before and add one of the most advanced messaging platforms to your toolkit.

  • Deploying your JS App Anywhere with .NET MAUI

    As a JS girl in a .NET World, I have recently started learning the power of MAUI. MAUI is a .NET framework used for creating native mobile and desktop apps. I learned how to utilize a WebView inside a .NET MAUI application to wrap any sort of web app I desired (Angular, React, Vue, you name it!) and deploy it with the power of MAUI to any platform under the sun. I’m excited to show you how to do this — bridging two worlds has never been more fun!

  • Discover .NET MAUI

    Maybe you’ve heard or used Xamarin or Xamarin.Forms, get ready for the next generation of your favourite framework!

  • Don’t Panic! Security’s here to assess your project.

    You and your team have been working on some web apps and APIs for a few sprints now, and you may or may not already have a version running in production, when out of the blue, the client announces that a security company will do an assessment of your project. If your initial reaction to this news is either being scared or concerned, you’re probably right. And you should probably attend this session.

    During this session, I’ll explain what is typically going happen during a security assessment, and show you how to prepare before the assessment happens: with code to apply security headers or tighten down attack vectors, and with a threat model to quickly identify how fast a project gains vulnerabilities. Not to scare you even more, but help you get the overview and identify where you can easily perform some quick yet safe wins.

  • Emulating a Game Boy in .NET 6

    In 1989, Nintendo released their first handheld console with cartridges, the Game Boy, which sold over 100 million of units. This device has been the inspiration for game developers around the world to start creating games, and even today, games are still being created for the Game Boy, although not officially on cartridges.

    Enter the world of emulation, where the Game Boy is now available as a .NET 6 project. Want to know more about how to emulate a CPU, graphical unit, hardware interrupts and more? Let’s dive into C# code and dusty hardware manuals on this journey back to our favorite Italian plumber.

  • From bulb to C# — how does computer work?

    Computers — we use them every day for work, entertainment, discoveries or even house management. Our watches are more powerful than computers used by NASA to put a man on the Moon. But do we really know how they work? What is von Neumann architecture, microcode, x86 and other magical terms? How is it possible that this little thing performs more calculations than we could ever do in our lives?

    In this talk we will see how it works. We will start with few bulbs emitting light and finish with computer capable of running the CLR. We will understand the magic behind it and what is actually going on “under the hood”.

  • Implementing and Debugging Custom MSBuild Tasks

    MSBuild is part of every .NET developer’s life in working with projects and solutions. It’s the system that ultimately invokes tools like the C# compiler or NuGet. Sometimes it makes sense to integrate additional tools into the MSBuild execution pipeline, also known as custom MSBuild tasks. However, implementing a custom task can be very daunting. Even advanced users are often running into issues when packaging, wiring or debugging their task in the full MSBuild infrastructure. In this session, we’ll walk through my personal setup for implementing custom tasks and look at a few tricks and tools that can greatly simplify our efforts.

  • Instant APIs with .NET

    Ever wanted to build CRUD API’s with .NET lightning fast while still being in charge of everything?

    In this session i’d like to demonstrate a growing open source project that enables you to build full API’s in seconds, heavily reducing the amount of boilerplate code you have to write. Effectively giving you more time to concentrate on what matters, your business logic and model.

    Based on .NET Core, Entity Framework you’ll learn how to write an API by just writing JSON or a simple class, how to further advance the API with custom events and validations and how to deploy it to Azure.

  • Integrating your ASP.NET Core application with the Azure Data Platform

    Handling data, especially big data, is always a challenge. Handling it efficiently is even more a challenge. Integrating it into a nice experience with your ASP.NET Core application is where things start to become really interesting.

    During this talk, we’ll show how we can architect a data ingestion and transformation flow in Azure, by leveraging services like Azure Data Factory, Azure Data Flow or run our AI code in Databricks, in order to be able to process big data at scale.

    Then we’ll see how we can streamline the user experience, integrating all of that with our Web Stack, built in ASP.NET Core and Blazor.

    As a last step, we’re going to implement a data visualization system with PowerBI, and show how we can embed reports and dashboard into our web application.

  • Introduction to project Orleans for your distributed applications

    Orleans is a cross-platform framework from the Microsoft Research team that helps you to build robust and scalable distributed applications. Orleans has been around for many years and is battle-tested by a number of internal Microsoft products and teams.
    In this code-heavy introductory session, I will explain what the Orleans framework is all about: What is the distributed virtual actor model? What are grains? How is a shared state stored in a distributed application?
    Finally, I will show you how I implemented Orleans in one of my personal projects to enable easier scaling.

  • Locks are tricky — let’s understand them by building one

    We’re often told that message passing is better than sharing the memory and protecting it with critical sections. But why? Can’t we just use lock keyword and call it a day? What can go wrong?

    In this talk we’ll dwell into concurrency primitives to understand how they work and what risks they bring. We’ll understand async magic. Finally, we’ll build a couple of custom primitives, for both non-async and async world in C#.

  • Message processing failed! But what’s the root cause?

    Teams that are new to building and maintaining distributed systems with messaging are faced with challenges when it comes to investigating failure scenarios. With messages flowing through the system, it’s hard to quickly identify where a failure originates from and why it’s occurring. Without a call stack to guide you, we need other techniques to keep a good overview.
    In this session, we’ll navigate how modeling techniques, integration testing, and instrumentation with OpenTelemetry can help you create visibility for your entire distributed system.

  • Performance tricks I learned from contributing to open source .NET packages

    As a practical learner, I’ve found performance optimizations are my biggest challenge and where I’ve learned the most helpful tricks, mostly by trial and error. It turns out the Azure .NET SDK is a perfect “playground” for learning those tricks—it’s maintained by people who care and give feedback.

    Over the past few years, I’ve contributed over fifty pull requests to the Azure .NET SDK. In this session, I’ll walk you through the performance improvements I made, and help you develop your own “superpowers”—spotting and avoiding closure allocations, finding opportunities for memory pooling, and more.

  • Running SaaS multi-tenant applications with ASP.NET Core and Azure

    Real world multi-tenant applications are conceptually simple, but hide lots of complexities under the hood: when confidential data of multiple clients coexist under the same platform, you must ensure that data is kept segregated at any layer of your architecture.

    During this talk we’ll try to demystify some of these aspects, analysing how we can build a SaaS application in ASP.NET Core, secure it via Azure AD B2C, and deliver it via the Azure infrastructure.

    We’ll investigate how to use policies in our server side logic and even at the database level (via SQL Server’s Row Level Security) to ensure data is kept segregated even when running on a shared infrastructure.

  • Serverless Containers with Azure, Containers Instances & Apps

    In the latest years, containers become the new standard to run workloads regardless the underlying compute runtime. But, the orchestrator cost is still there, in most of the scenarios. With Azure, we can use containers without all the hassle of managing K8s, first with Azure Container Instances and now with Azure Container Apps. Come with me in this session to see how we made it run in production with those amazing tools.

  • The Final Frontier: Security APIs in Modern Browsers

    A while ago, web browsers were considered the #1 security risk on the web. Today, they are the last line of defense. Over the course of the previous decade, many security mechanisms and APIs were integrated into web browsers. These measures can protect a site from many common attacks, provide additional security functionality like authentication, and limit the attack surface by restricting what the browser is allowed to do. Learn how some of the most dangerous attacks just cease to work, and how easy it is to add an additional layer of security. This code-heavy session will demonstrate many of those security features, unveil what is coming in the future, and which functionality will be deprecated.

  • Understanding Microservices: a guide for the monolithic developer

    Microservice Architecture and the reasons why you should move to it, and the reasons you shouldn’t, have been well discussed.
    If you have already decided to move over to microservices from monolithic development, then you may be finding the whole process a bit daunting.
    What aspects should you, a developer be concerned with?
    What does all the terminology mean?
    How do the services talk to each other?
    In this session, I will show you how to get started with microservices architecture, answering these questions and many more.
    We’ll look at The Tacky Tacos project, built with ASP.NET 6, and explore how the whole process fits together from a development point of view.
    Hopefully, you’ll leave the session with the confidence to start your own microservices application development straight away!

  • What is new in .NET 7 and C# 11

    November 2022 marks the release of .NET 7 and C# 11. In this session, I will talk about what is new in the latest version of .NET and what the future will bring for the .NET platform in general. Expect a number of new .NET 7 and C# 11 features and examples of those features.

  • What sorcery is this? How Software uses Dark Patterns to Manipulate Users

    You’ve signed up for that streaming service, but now you can’t unsubscribe. You put a single item in your basket, and somehow there are now also two warranties in there. Boxes of vitamin supplements are piling up every month like a subscription, but you are absolutely sure you only bought one bottle! In your living room is a big pile of stuff that you bought online, that you didn’t intend to. And you feel bad about it because now you’re way over budget! If you’ve had something like this happen then you may have experienced a dark pattern – something software does to trick you into taking an action you wouldn’t have otherwise taken. In this talk, you’ll learn how to spot and avoid dark patterns when using or creating software. You’ll also get pointers about talking to management about the impacts of dark patterns. And of course, a look at a few physical-world examples of dark patterns too.

Session and Speaker Management powered by

HURRY UP! Book your Seat