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!


Talk (60 min)

Understanding Microservices: a guide for the monolithic developer

Microservices

In this session we will explore the benefits and challenges that quantum devices bring for cryptography. We will discuss how quantum key distribution can facilitate unbreakable encryption, how the laws of quantum mechanics can be applied as security features and how quantum computers can pose threat to our established cryptographic schemes.

Quantum Computing and the future of cryptography

Security

In this talk we're going to learn practical tricks in today's Internet. We'll see how to connect to multiple VPNs and force enable split tunnel, how to keep connection alive even when the network is down, or how to connect to VNC exposed directly on the CPU level, way below the operating system layer. All of that free of charge and with no hassle! This talk is heavily based on live demos.

Connect remotely like a pro! Hack VPNs, avoid firewalls, connect even when your machine is down

Agile

Tools

An Introduction to Blazor in .NET 8

.NET

JavaScript

We will start our Jedi training from the basics of what TDD is, why you should be doing it, and how it improves the quality of your software. We will also talk about what TDD is not and where developers often go wrong with TDD and succumb to the dark side. All along the way, we will do live coding demos so that you can see TDD in action. Demos will be in C#, but the TDD concepts apply to any language.

Test Driven Development with C# - from Padawan to Jedi

Testing

Recent advances in generative AI, like Stable Diffusion and Chat-GPT, have the industry more hyped up than a caffeine-addicted toddler. It can leave one feeling like they're being left behind if they're not incorporating AI into their apps today.


In this talk, we'll take a sober look at the topic of Generative AIs. In particular, we'll look at how Large Language Models (LLMs) work and where they break down. We'll consider how to engineer prompts for AI. And finally, we'll look at practical examples of adding AI into into a real-world app based on my experiences introducing AI into https://ab.bot/, an app designed to help customer success teams support their customers. We'll write code that calls Open AI APIs that demonstrate how to sprinkle a little AI into your own app. Join us to learn how to leverage the latest advancements in generative AI and take your applications to the next level.

Practical Applications of Generative AI: How to Sprinkle a Little AI in Your App

As software developers, we often lean on heuristics and truths that we collect throughout our career. For example: start small and scale up later, iterate and ship often, failure is learning, good enough is good enough. These are actually pretty powerful insights that can be applied in other areas and not just in software development.

So what about these other areas, like teaching, economics and acting? What do people in these industries and professions just “know”? And can we apply it to software development? 

This talk takes a lighthearted look at several different professions and pulls these insights together to offer you a fresh perspective on your work.

A Teacher, an Economist and a Developer Walk Into a Bar

If a small change in business logic or in data requires you to modify code in more than one service, you probably are. Isn't it unbelievable that even using the latest technologies like .NET Core, containers, serverless and more doesn't help? In this session we'll discuss why technology doesn't change coupling. We'll have a different look at microservices. One where they'll truly be autonomous and not share data at all.

Autonomous microservices don't share data. Period.

Architecture

Design

The cloud holds a dirty secret: it generates greenhouse gas emissions on par with entire countries such as France or the United Kingdom (IEA, 2021). But there is hope! Infra & Cloud teams have the power to mitigate this issue. It all starts with a simple decision: choosing the right cloud region on platforms like GCP, Azure, or AWS. And guess what? This choice can reduce emissions by a factor of 10 or even 20! For instance, Ireland has a carbon intensity of 400 gCO2eq/kWh, while the French network can go as low as 20 g. I will demonstrate how we can measure and drastically reduce these emissions, making our cloud "carbon-aware."

- Address the issue of CO2 emissions in the cloud.
- Present the regulatory and financial landscape that compels us to address this problem.
- Introduce techniques to measure and estimate emissions using observability tools.
- Discuss practical methods to reduce the carbon footprint of your cloud infrastructure.
- Explain the concept of "carbon-awareness," where infrastructure dynamically self-adjusts based on emissions.
- Live demo showcasing a carbon-aware infrastructure.

# Who am I ?
Ex-first dev at Canva in Sydney and Elastic for several years, I have launched Carbonifer, a project aiming to make cloud infrastructures "carbon-aware."

Although this talk will not specifically focus on Carbonifer (no advertising), I will mention it among other tools.

Because the world is changing, and regulations and investors are urging action. National and European regulations are being enacted to ensure companies measure their carbon footprint. Companies will need to demonstrate tangible efforts, while ESG funds seek to invest in environmentally responsible enterprises. Moreover, adopting a sustainable approach serves as a powerful tool to attract talent and retain clients.

"You can't improve what you don't measure." - Peter Drucker

I will showcase the use of observability tools to estimate emissions in real-time for your cloud infrastructure. The carbon intensity of the electricity powering data centers is publicly available data, enabling us to make real-time estimations of cloud emissions.

Once we can measure, the next step is action. I will present practical methods to reduce the carbon footprint of your cloud infrastructure. We will go beyond simply pausing underutilised machines and explore options such as choosing low-emission regions. Additionally, leveraging auto-scaling groups and serverless services allows to keep emissions to a minimum.

We can imagine an infrastructure that self-adapts based on its own emissions. When the electricity powering a region becomes too carbon-intensive, we can automatically reduce the number of machines in the cluster or temporarily relocate it to a region with lower carbon intensity.

To illustrate this concept, I will demonstrate how an infrastructure can seamlessly "move" a cluster of instances between regions based on the carbon intensity of the electrical grid, without any downtime or compromising service quality. Furthermore, we will explore intelligent scheduling of resource-intensive tasks, such as AI model training and video processing, taking advantage of regions with lower carbon intensity or favorable weather conditions.

All of this serves to demonstrate how infrastructure can dynamically adjust to emissions and become "carbon-aware"!


Toward a carbon-aware Cloud

Cloud

DevOps

Ethics

This talk will explore the fundamentals of corporate finance in terms developers will understand - by using Domain-Driven Design modelling techniques such as Event Storming and Domain Storytelling.

We'll start with the basics of business health - understanding profit & loss statements, balance sheets and cash-flow reports.

Then we'll look at how businesses are valued (privately and on the stock-market), and how that affects different funding and ownership models - for example angel investing, venture capital & private equity.

Building on this, we'll explore common long term incentive structures such as options and SAFE notes and how they can be impacted by preference shares.

At the end of this talk, you'll be well equipped to understand what the long term prospects of your future employers are and how to assess the potential risks and rewards of various compensation plans - and you might learn a bit about Domain-Driven Design along the way!

DDD Explains: What are my stock options actually worth?

Soft Skills

Yet sometimes, the right use of ARIA can improve your UI better for end users. In this talk, we'll look at practical examples of effective ARIA usage and how they work in assistive technologies. Find out more about the patterns that have broad support and which ones to avoid. Let's look at ARIA, the good parts!

ARIA: the good parts

However, successfully implementing Zero Trust is challenging, since it cannot rely on a single product or reference architecture. Zero Trust is an approach which requires cooperation among multiple products not initially designed to work together in a secure and cohesive way.
When I first explored the concepts at the heart of Zero Trust, I realized that I was already familiar with these paradigms from the architecture of video security systems. Video is the ultimate ‘zero trust’ challenge because content providers do not have much (any!) faith in their viewers, and assume a constant threat of piracy.
This talk is for everyone who wants to build a secure system. You will leave this talk with an understanding of what Zero Trust is and isn't, beyond the buzzwords. We will explore the principles of Zero Trust, including an overview of concepts that can be used to build a zero trust system, such as a Trusted Computing Base (TCB), a chain of trust vs. trusted third parties, managed vs. unmanaged devices, identity authentication and cloning prevention. We will discuss what we can learn from video security, in order to design and implement a robust perimeter-less security model.


What the Premier League can teach us about Zero Trust

Yes! And everywhere else. We can't shut off learning, and we can't stop ourselves from seeing the connection in everyday things.

Learning and inspiration can come from any place, so why not look at the unsung heroes - Disney Princesses and see what we can learn about leading tech teams from them?

Whether it is Raya's quest to create a united Kumandra or Rapunzle's wish to start something, there are lessons for us technical leaders hidden in the depths of the Disney movie tomb.

Join Martin for a fun and entertaining session about what I learned from watching movies, listening to songs, and role-playing princess with my daughter over the last few years.

You will get seven memorable lessons about leadership accompanied by songs (not sung by Martin) to help you remember them.

7 Things Technical Leaders can Learn from Disney Princesses

People

I contend that, in fact, you have too much time, and it’s keeping you from changing the world. In the same way that too many choices forces indecision, having too much time brings its own share of challenges. This talk will address ways you can identify what your real priorities are (vs. what you tell yourself), show you how much of your days are truly wasted, and help you to stop feeling so overwhelmed.

You Have Too Much Time

In this session, we will learn how to best use async/await in C# by analyzing how .NET compiles our async code.

Join me as we take an existing app and optimize its async code together, showing off performance gains, better exception handling, improved run-time speed, and smaller app size! 

Correcting Common Async/Await Mistakes in .NET 8

Concurrency

In this talk, we’ll visit the reasons for migrating our 10Gb/s ingest pipeline to the cloud, examine our new architecture and its benefits, and focus on how Kafka played a key role in this transformation.
Whereas Kafka is mostly used either for operational messaging or as a streaming storage for actual events, this session will provide you with a unique way of leveraging many of Kafka’s advantages in a big data pipeline.


The Metamorphosis: How Kafka helped us migrate our 10Gb/s ingest pipeline to the cloud

However, traditional observability tools and techniques can only go so far in providing insights into the behavior of these systems. Enter ChatGPT, a conversational AI tool that can help bridge the gap between observability and human understanding.

In this session, we will explore ChatGPT and how it could theoretically be used to enhance an enterprise’s observability practices. We will briefly look at how ChatGPT can be trained to understand and interpret system logs, metrics, and other observability data, and explore whether it can provide useful real-time insights and recommendations to engineers and operators.

By attending this session, you will gain a deeper understanding of how conversational AI can be leveraged to improve observability in software systems, and how ChatGPT help you avoid potential issues before they become critical problems.

Exploring ChatGPT for Improved Observability

Machine Learning

Let's explore the latest technologies, including Azure OpenAI, Neural voice, and GitHub Co-pilot. With Co-pilot, an AI-powered coding assistant that suggests code snippets based on project context, developers can boost productivity. We'll also discuss the importance of developing AI in a way that benefits society as a whole.

Don't miss this opportunity to learn and discover how you can leverage AI to drive innovation in your own organization.

Unlocking the Potential of AI

If you fall behind your peers and don’t reach your full earning potential. This talk demystifies negotiation and empowers the attendees to earn as much as their peers while staying true to their personality.

Key Learnings:
- Why negotiation is an equality issue
- How to prepare to negotiate
- Non-monetary benefits you can negotiate
- Components of a successful negotiation script
- “Power moves” that are polite

A People Pleaser's Guide to Salary Negotiation

Work skills

Workshop (60 min)

Reframing Problems through Experiential Exercises

Join me as I take us on an adventure to find the beasts i.e. the different ways Data Science projects can fail. I will be talking about 4 major reasons for failure (data, infrastructure, implementation, and culture), their different aspects, and supplementing it with my experiences and case studies. I will also share how to control these beasts and recommend actions to be taken to ensure a successful end-to-end Data Science project.

By the end of this session, audience members will have a better understanding of the different ways a Data Science project can fail. They will be able to identify points of failure in the context of different case studies. They will feel motivated to share and learn from their failures and leave with actionable steps to reduce the risk of failing.

Data Science beasts (failures) and where to find them

Big Data

This hands-on session teaches how to explore datasets, use Machine Learning algorithms and derive insights from predictive models using popular tools in Python like Jupyter, pandas, sklearn and numpy. This tutorial is aimed at budding data scientists who have previous programming experience, though it doesn’t have to be in Python.

By the end of this tutorial, participants will be able to clean and investigate datasets, create and evaluate predictive models and visualize the results. The vision is that participants feel motivated to create or pick up a dataset, investigate it and answer questions based on the insights derived - whether it’s to make informed business decisions or book a flight that is likely to be on time.

Part 1/2: Learning Data Science in Python

However, securing cloud-native applications presents a complex, multidimensional challenge that involves various teams, workflows, and infrastructure layers. As the attack surface expands, companies must enhance their understanding of how to bolster their security posture.

In this talk, we will delve into the cloud-native security landscape and demystify the numerous acronyms in the field, including CSPM, KSPM, CIEM, CWPP, CDR, and CNAPP. For each acronym, we will explore its meaning and associated attack surface, examine real-world exploitation examples, and discuss relevant research data. Furthermore, we will demonstrate an attack, such as Log4Shell, and explain how it relates to different security layers.

This presentation is designed for professionals in the computer software industry seeking to gain a better understanding of the cloud-native security landscape.

Navigating the Cloud Native Security Landscape

Docker

This enables you to build rich user interfaces with minimal client-side code, while still preserving interactivity and performance.

In this talk, you will learn how React Server Components work, how to use them in your web apps, and what benefits they offer over traditional approaches. You will also see some real-world examples of React Server Components in action and get some tips and best practices for adopting them in your projects.

React Server Components: A New Way to Build Fast and Interactive Web Apps

Fast forward half a century, and the relationship between email and commerce has never been more complicated. In one sense, the utopian ideal of free, decentralised, electronic communication has come true. Email is the ultimate cross-network, cross-platform communication protocol. In another sense, it's an arms race: mail providers and ISPs implement ever more stringent checks and policies to prevent junk mail, and if that means the occasional important message gets sent to junk by mistake, then hey, no big deal - until you're sending out event tickets and discover that every company who uses Mimecast has decided your mail relay is sending junk. Marketing teams want beautiful, colourful, responsive emails, but their customers' mail clients are still using a subset of HTML 3.2 that doesn't even support CSS rules. And let's not even get started on how you design an email when half your readers will be using "dark mode" so everything ends up on a black background.

Email is too big to change, too broken to fix... and too important to ignore. So let's look at what we need to know to get it right. We'll learn about DNS, about MX and DKIM and SPF records. We'll learn about how MIME actually works (and what happens when it doesn't). We'll learn about tools like Papercut, Mailtrap, Mailjet, Foundation, and how to incorporate them into your development process. If you're lucky, you'll even learn about UTF-7, the most cursed encoding in the history of information systems. Modern email is hacks top of hacks on top of hacks... but, hey, it's also how you got your ticket to be here today, so why not come along and find out how it actually works? 

Email vs Capitalism, or, Why We Can't Have Nice Things

As machine learning moves from the research lab to the enterprise, questions around ethics and risk become even more critical. Ethics and governance cannot be applied on the backend and must be considered from the beginning and throughout the development process. Attend this talk to learn how to incorporate ethics and risk into your machine learning development process.

Ethical Machine Learning

In this talk, we'll go through Tracing, Metrics, and Logs from a .NET perspective. I'll show how easy and simple it is to implement, and give you the heads up on the gotchas you might face.

Practical OpenTelemetry for .NET

Microsoft

Placeholder

From "I can get this done in a week" to "My job is to write code", developers often convince themselves of things that are only partially true - or even outright ridiculous.

These seductive-but-false notions are factors in everything from poor software quality to unnecessary stress on developers and other team members. In this session, developer/designer/architect Billy Hollis will bring out his top ten uncomfortable truths about software development, with some humor to make them easier to hear.

Lies Developers Tell Themselves

Part 2/2: Learning Data Science in Python

Getting communication wrong leads to problems anywhere between 'my code is buggy' to 'this project is 6 months overdue and doesn't meet any of the requirements'. There are thousands of books, webinars and conference talks out there about how to communicate more effectively, and we still haven't figured it out.


In this talk, I'll take you through some rigorous frameworks for thinking about communication, and explain how they can help you talk both to people and to computers. I'll argue that it's actually much easier to communicate with computers than other human beings, and that the inability to communicate perfectly isn't a failure - it's normal. Finally, I'll talk about what all of this means for us as engineers, designers and producers of software, and what we can do to make all our lives a little easier.

Opening Keynote: Language Games

Over the last years of my career, I have applied practices to decision-making that have significantly improved my decision-making and how I evaluate and challenge decisions made by others. In this session, I'll share the essential building blocks that improve critical thinking, help break through biases, and improve our intent and communication when making impactful decisions. You'll learn to apply tactics to help identify assumptions, evaluate options objectively, and assess risk. You'll walk out of this session with actionable takeaways that will help strengthen your decisions in our complex and ever-changing technology landscape.

Mirror, mirror on the wall... Am I a critical thinker after all?

.NET Rocks Live

I'll tell you my story, and the lessons I learned in order to overcome it. Think you aren't good enough? Let's talk about it.

Imposter Syndrome: Overcoming Self-Doubt in Success

In this session we'll talk about intentionality in software design - and how you can radically simplify the way you build applications today to make them more meaningful to the humans that maintain them.

A radical look into why *every single character matters*, and why you should probably burn your copies of Clean Code.

Intentional Code - Minimalism in a World of Dogmatic Design

So I was thinking, what would the most ludicrous and stupid things to try and implement in JavaScript?

How about a 3d engine? How about three? A rasterizer, a ray-marcher, and the almighty ray-tracer!

We will go through how I built, three different 3d engines in JavaScript and the lessons learned.

You can't do that with JavaScript!

But with containers, this becomes bit more complicated. There are many layers of possible failure running under your application.

In this session you will learn more about the different layers you should be releasing your chaos experiments on, the considerations you need to take into account while testing a shared platform, and also learn about the tooling available to accomplish this.


Creating chaos in containers

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 seventy 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.

Performance tricks I learned from contributing to the Azure .NET SDK

Being able to participate in, and even drive, Difficult Conversations means we can resolve the challenges of our relationships with other people, but it also means we can earn their trust and respect. When we are able to engage truthfully and respectfully with the people around us we can improve our relationships with them and smooth out the inevitable bumps on the road.

- What Difficult Conversations are and what happens when you ignore them
- Why having Difficult Conversations can be beneficial to you, your team, and your career
- A framework to help you prepare for Difficult Conversations

Debugging Difficult Conversations - Or "How not to chicken out"

In this session, we'll take examples from real-world F# code, and see what that code decompiles to in C#, giving you an essential low-level bridge between the languages through the .NET Runtime and IL byte-code.

While some basic functional constructs will be shown, the goal of this session is not to teach category theory and monads; it's to show how functional constructs in F# get translated into C# constructs that you're already familiar with. We'll highlight the benefits of using F# to "say" those things in succinct, robust, beautiful ways that help you write clear, maintainable code, and show how to bring some of those constructs back into C#.

At the end, you'll have an appreciation of some of the ways F# lets you write beautiful, expressive code that takes full advantage of everything .NET has to offer. Even if you never write F# yourself, this session will give you tools and new perspectives on C# that you can start applying to your projects right away for better, cleaner, easier-to-test code.

F# for the C# Developer - F#, the .NET Runtime, and Aesthetics

Functional Programming

Languages

Despite progress in many other areas, AI has historically stopped short of improving software development practices. Enter GitHub Copilot: the software industry’s first artificial intelligence solution that distills the collective knowledge of the world’s developers into an editor extension that suggests code in real time. ChatGPT then took the world by storm with its conversational capabilities and public reactions have been quite telling.

This makes the process of building great software easier and faster, but what about more secure? In this session, we’ll demonstrate how GitHub Copilot and ChatGPT can help developers write more secure code through real-world use cases. The audience will come away with tips and best practices from the lessons we learned from experimenting with the tools.

Human vs AI: How to ship secure code

At this stage, the hype surrounding AI has far surpassed the actual useful information available.

In this presentation, we’ll cut through the noise and delve deep into the current applications, risks, and limitations of these generative AI models. We will start with the early research endeavours aimed at creating an "artificial brain" and trace the path that has led us to today's sophisticated models. Along the way, we will address the misconception of mistaking these models for intelligent systems and shed light on the actual requirements for developing true artificial general intelligence, and see how far we seem to be from this goal. Moreover, we will highlight how an excessive focus on topics like the sentience of these systems has overshadowed the genuine issues associated with these models. By shifting our attention towards their real limitations, we will see how we can better maximise the potential of these exciting models.

Separating fact from fiction in a world of AI fairytales

After the pandemic, the increased adoption of remote work has further accelerated this trend. 💻🦠

However, even those who are culturally informed, travel extensively, and have lived abroad often struggle with the cross-cultural complexity that affects their daily interactions. If I am arriving 7 minutes late to a meeting in France, should I let them know? ⏱ And what if the meeting was in Norway? Why are my Latin American colleagues using so much time in personal talk before asking for something at work instead of getting straight to the point? 😩 My American manager gave me three positive feedback before telling me a negative one that she didn’t even make it sound so terrible… that has to be something good, right? 😰

As an Argentinian living and working for years on the other side of the world, often in teams with people from very different backgrounds, I know the answers to these questions aren't always easy. That's why In this session I want to share an incredible finding I recently came across: an analytical framework for decoding how these cultural differences impact our work environment called “The Culture Map”, conceived by international business professor Erin Meyer, and what things we can do to become better colleagues in this multicultural world 🌍


The Culture Map - Navigating through the complexities of the cross cultural workplace

What starts with code and ends with releasing/deploying software is also being referred at as the software supply chain. Over the last years we've seen some big security incidents tied to the software supply chain and the software industry acknowledged there was a need for action. And today there is a lot to choose from, but what will be the most effective things to do? We'll start out with a GitHub repository that contains a .NET application and work our way through in securing the supply chain by covering the following subjects:

- Defining the software supply-chain security risks
- Git commit signing
- Reproducible Builds
- Understanding used 3rd party libraries
- Creating Software-Bill of Materials (SBOM)
- Google SLSA
- Signing code and artifacts
- My supply chain got hacked, now what?

A side from having access to GitHub you also need to bring your own .NET development machine to participate in this workshop.

Part 1/2: Securing your .NET application software supply-chain, the practical approach!

Nullability syntax and annotations give hints as to whether a type can be nullable or not, and better static analysis is available to catch unhandled nulls while developing your code. What's not to like?

Introducing explicit nullability into an existing code bases is a Herculean effort. There's much more to it than just sprinkling some `?` and `!` throughout your code. It's not a silver bullet either: you'll still need to check non-nullable variables for null.

In this talk, we'll see some techniques and approaches that worked for me, and explore how you can migrate an existing code base to use the full potential of C# nullability.

Bringing C# nullability into existing code - dammit is not the answer!

GraphQL has become the go-to choice for building modern APIs, with some of the biggest companies in the industry transitioning to this technology as we speak.

But with great power comes great responsibility. If you're new to GraphQL, it's easy to fall into some common pitfalls that can derail your progress. That's where this talk comes in. We're going to take a deep dive into the best practices for putting GraphQL in production and explore the challenges that await you on your journey.

We'll start by looking at how to apply authorization concepts to your GraphQL API, ensuring that your data is protected against unauthorized access. Next, we'll explore techniques for securing your GraphQL backend against malicious requests, including input validation and sanitization.

But that's just the beginning. We'll also cover strategies for optimizing the performance of your GraphQL server, including real-time functionality and caching. We'll discuss how to scale your GraphQL API properly, ensuring that it can handle the demands of your growing user base.

Throughout the talk, we'll share practical examples and real-world experiences that will leave you feeling inspired and ready to tackle the challenges of building production-ready GraphQL APIs. Whether you're a seasoned GraphQL developer or just getting started, you won't want to miss this exciting and informative session. Join us and learn how to build secure, performant, and reliable GraphQL APIs that are ready for the real world!

Production-Ready GraphQL APIs: Ensuring Security, Performance, and Scalability

GraphQL has emerged as a powerful tool for building APIs that are both flexible and efficient. However, as our applications and teams grow, managing a monolithic GraphQL API can become challenging.

In this talk, we will explore the benefits of building distributed GraphQL APIs. We will cover the basics of GraphQL federation and how it allows us to break up our GraphQL schema into smaller, more manageable pieces. We'll also dive into some of the challenges of building distributed GraphQL APIs, such as schema stitching and resolver conflicts, and explore some of the best practices for overcoming them.

Throughout the talk, we'll provide practical examples and share real-world experiences of building distributed GraphQL APIs. Whether you're just getting started with GraphQL or you're an experienced GraphQL developer, you'll come away with a deeper understanding of how to build scalable and maintainable APIs using GraphQL federation. Join us to learn how to take your GraphQL APIs to the next level!

Distributed GraphQL APIs: Breaking Down Monoliths and Unlocking Agility for Development Teams

While a globally distributed fault-tolerant microservices architecture might be an interesting and fun challenge to build, diving in too early will likely result in disaster. This talk tells the story of a team's journey from a monolithic architecture to event driven microservices, including missteps and learning opportunities they discovered along the way.

Just in Time Architecture

However, the truth is that we oldies have a big advantage over the younglings.

We are slow! Slow is good! So whatever you do, don’t put your programming on the shelf just because someone half as old writes code with twice the speed.

Instead of getting frustrated over the pace of the oldies I really believe that we need to take a step back, embrace the skill of being slow and change the developer mindset to understand that the best way to go fast in the long run often is to be “controlled slow” in the short run.

In this highly interactive talk I will elaborate on the danger with the traditional “software developer life cycle” (developer -> team lead -> project leader -> manager) and try to show how we instead can make those grey hairs your biggest asset, just by slowing down.

Get old, go slow, write code!

Attendees should be able to take away a clear set of guidelines as to how they should be approaching TDD to be successful. The session is intended to be pragmatic advice on how to follow the ideas outlined in my 2013 talk "TDD Where Did it All Go Wrong"

TDD Revisited

As a developer advocate, I've had a fair bit of experience with user testing and public betas, and I want to share some of the things I’ve picked up along the way. For example, when does it make sense to use a public beta? How do you handle documentation when something isn’t quite official yet, and might be replacing an existing feature? When is it too early to go to beta - or too late?

In this talk, I’ll discuss why and when you might want to run a public beta, and what you can expect out of the experience - good, bad, and ugly. I’ll talk about user feedback: ways to collect it, how to interpret it, and whether you should act on it. Finally, I’ll talk about how to decide when it’s all over, and what to bear in mind as you take the plunge into General Availability.

This talk is aimed at anyone with an interest in feature launches and user engagement. The audience should come away with a good idea of when public betas make sense as a strategy, what the goals of that beta should be, and how best to achieve them.


User testing in production: how to run a public beta

Learn how to do all of this in pure C#, no C or C++ required! In this talk, we’ll be looking at pointers, unions, unmanaged memory, implementing IDisposable and finalizers, and how to call and be called by native code.

Introduction to unsafe C#: Calling native code and crashing in entirely new ways

Whereas a synchronous (request/response) invocation involves immediate authorization of known parties, e.g. one microservice directly calling another, the complexity of enforcing permissions in a decoupled, dynamic system (where the producer of a message has no knowledge of who consumes it, and when) has typically limited access control to be performed at the application boundary, commonly in API gateways; this leaves internal services and assets vulnerable to threats by any unauthorized subject, violating key principles of a zero trust environment.

This session focuses on securing access in a message-driven architecture using a token based approach with Open Policy Agent (OPA), allowing for verification of each message and the claims of users and services at critical points throughout the asynchronous communication flow. The characteristics of disparate message types (e.g. a command routed to a single target handler vs an event that reaches one or more subscribers, may be stored long-term, replayed and possibly cross application boundaries), and their implications for how, where and when to perform access control will be detailed with concrete examples, along with a discussion of performance and scalability aspects as well as how to implement and deploy permission policies.

As we move towards building message-driven systems that operate in constantly-changing conditions, implementing novel access control measures that support zero trust and emerging interaction patterns becomes essential; this talk will help you achieve that.

Access control in message-driven systems

Software teams embrace practices such as continuous integration and test automation as building, testing and deploying and increasingly complex codebase becomes impossible.
In order to succeed with automatic testing in a cloud based, microservice architecture you will need clear guidelines and rules that will help you decide what to test and how to test your micro services.
In this talk I will cover the test pyramid and how it applies to ASP.NET core microservice and the different types of automatic tests needed to guarantee high quality in your software project

Testing strategy for your cloud based ASP.NET Core services

Even when the workflow system temporarily is unavailable, they are expected to continue where they left once they are up and running again. Quite a daunting task if you need to write or manage this yourself.

In this session, I'll cover workflow as code using Dapr Workflow, a new Dapr (Distributed Application Runtime) building block that allows developers to build resilient and long-running workflows. As the 10th largest CNCF project, Dapr is used in production by companies like IBM, Alibaba Cloud & Microsoft and is a trusted OSS technology backed by a vibrant developer community.

I'll go into the specific workflow features, such as scheduling, sequential and parallel execution, and external event triggers. I'll show many code samples (in C#) for each of these features and will run the workflows locally using the Dapr CLI to demonstrate their resiliency.

By the end of the session, you will have a good grasp of workflow as code and want to use it yourself to build distributed applications.

Orchestrate your business logic reliably with workflow as code

Many organizations follow that trend in building their own developer platforms to increase the efficiency of their engineering teams.

But what when these platforms turn into what we wanted to avoid in the first place: beasts that can hardly be tamed, eating up cognitive load of engineers, and ultimately being doomed to fail? Then we've most likely landed in the world of platform monoliths, an emerging anti-pattern. Monolithic platforms lead to a large blast radius, a lack of adaptability to evolution, and a heavy loss in overall engineering efficiency.

Without doubt, for many high-paced organizations, developer platforms can be a game-changing tool. In this talk, I will share strategies and methods to overcome the fallacies of building platform monoliths and instead to create a foundation that truly accelerates your engineering impact. Together we will rethink our understanding of platforms and what is necessary to unleash their full potential.

Why Your Platform Monolith Is Probably a Bad Idea

Sometimes this means we produce some bizarre code, some of our worst code, either through lack of knowledge or understanding, or due to the time constraints we were given.

But some of that worst code, ends up being some of our best code, in that it exceled at what it was required to do, solved problems that weren't even envisaged and was ultimately successful.

NDC { Porto }

Agenda

09:00 - 10:00 (UTC+01)

Opening Keynote: Language Games

Eli Holderness

10:20 - 11:20 (UTC+01)

Test Driven Development with C# - from Padawan to Jedi

Scott Sauber

An Introduction to Blazor in .NET 8

Carl Franklin

Practical Applications of Generative AI: How to Sprinkle a Little AI in Your App

Phil Haack

React Server Components: A New Way to Build Fast and Interactive Web Apps

Aurora Lid Walberg

Part 1/2: Learning Data Science in Python

Grishma Jena

11:40 - 12:40 (UTC+01)

Correcting Common Async/Await Mistakes in .NET 8

Brandon Minnick

Understanding Microservices: a guide for the monolithic developer

Layla Porter

Connect remotely like a pro! Hack VPNs, avoid firewalls, connect even when your machine is down

Adam Furmanek

Unlocking the Potential of AI

Henk Boelman

April Edwards

Toward a carbon-aware Cloud

Olivier Bierlaire

Part 2/2: Learning Data Science in Python

Grishma Jena

13:40 - 14:40 (UTC+01)

.NET Rocks Live

Richard Campbell

Carl Franklin

Charity Majors

A People Pleaser's Guide to Salary Negotiation

Colleen Lavin

What the Premier League can teach us about Zero Trust

Michal Davidson

Quantum Computing and the future of cryptography

Filip W.

The Metamorphosis: How Kafka helped us migrate our 10Gb/s ingest pipeline to the cloud

Yaniv Kunda

Reframing Problems through Experiential Exercises

Jessie Shternshus

15:00 - 16:00 (UTC+01)

Ethical Machine Learning

Kesha Williams

You Have Too Much Time

Jeff Blankenburg

Autonomous microservices don't share data. Period.

Dennis van der Stelt

ARIA: the good parts

Hidde de Vries

Data Science beasts (failures) and where to find them

Grishma Jena

16:20 - 17:20 (UTC+01)

Email vs Capitalism, or, Why We Can't Have Nice Things

Dylan Beattie

Exploring ChatGPT for Improved Observability

Gareth Emslie

DDD Explains: What are my stock options actually worth?

Chris Simon

Navigating the Cloud Native Security Landscape

Pablo Musa

Placeholder

Charity Majors

17:40 - 18:40 (UTC+01)

Mirror, mirror on the wall... Am I a critical thinker after all?

Laila Bougria

A Teacher, an Economist and a Developer Walk Into a Bar

Adele Carpenter

7 Things Technical Leaders can Learn from Disney Princesses

Martin Mazur

Practical OpenTelemetry for .NET

Martin Thwaites

Lies Developers Tell Themselves

Billy Hollis