Join Scott Hanselman as he walks you through the state of the art of Linux on Windows. What's possible, what's not, what about the Windows Terminal and Docker? Tons of lives demos in this highly technical session.

Talk (60 min)

Developing for Linux on Windows with WSL and Windows Terminal

Linux

In this talk we will learn how async is implemented, see what problems it creates, and explore other possible approaches. We will reimplement some of its features with monads, coroutines, and fibers to see how it could look like in an alternative world. We'll see if we can do better than the thread-pool based approach.

This is loosely related to project Loom in JVM world which explores fibers to improve threading.

Implementing async with coroutines and fibers - project Loom in C#

.NET

Concurrency

Choosing the right partition key for your Azure Cosmos DB containers is an important task. In the first half of this session, I will explain how Physical and logical partitions work in Azure Cosmos DB.
We will explore the importance of indexing data properties. This step is critical in Cosmos DB just like many other databases. You can easily reduce your Azure Cosmos DB bill by indexing the right properties of your data. In the second half of this session, we will focus on expanding upon available index types of Cosmos DB. I will explain how to handle Indexing policies to include or exclude data properties.
Please join me as I share how to develop affordable, scalable, and fast Azure Cosmos DB solutions.

Cost cutting strategies for Azure Cosmos DB

Cloud

Database

With fifteen years in IT and a successful career as a world-class infrastructure engineer, a speaker at many industry conferences, a blogger, analyst and technical marketing freelancer for Silicon Valley Startups and a CTO of a 1200+ infra and software engineering company, I can definitely say I suffer from impostor syndrome, and by extension, perfectionism.

And it doesn’t go away with success. The opposite seems to be true, actually. I’ve learned to harness it, spending a lot of time way out of my comfort zone to figure out how to come to terms with it and use it for good. Maybe the fact that I experience the syndrome makes me more humble, which makes me more valuable as a leader.

I’m here to show the little things I did differently every day:
1.	How being kind to yourself is key. Forgive, don’t judge. Accept who you are.
2.	Learn about your internal convictions and expose these to the world authenticly and honestly.
3.	How complimenting yourself and others goes a long way
4.	Build a case for yourself by keep notes of people saying nice things about you
5.	Self-doubt is a powerful tool as a leader, if used consciously
6.	Focus on (professional) relationships, not on technical merit
7.	Harness feedback, even it’s scary

With these small, incremental improvements, I now live in a self-inflicted, perpetually non-existing comfort zone. I’m constantly in the imposter zone, because I’m constantly doing new things, learning new skills, meeting new people. And I love it! It has brought me many smaller and larger victories, a career that’s led me to new and unexpected ventures and most importantly, a network of friends and relationships I otherwise would never have had.

Come listen to me, I’m a fraud! A story on success, impostor syndrome and self-inflicted, perpetuall

In Chapter 8 of the original DDD book, Eric Evans talks about making a big domain breakthrough after a long New York winter of refactoring on an inherited legacy codebase.

Eric's story emphasises the importance of models and modelling breakthroughs. I'd like to re-visit this story and show you how many of the insights are still highly relevant to modern software development... possibly even more so.

Share Pie: The DDD Treasure Hidden in Plain Sight

Architecture

Design

Soft Skills

In this workshop, you will work through scenario-based activities in groups. Each scenario will provide the design of one or more Bounded Contexts as Bounded Context Canvases. In small groups, your challenge is to review the design by identifying the positive and negative design choices, and flagging up areas of the design that need further attention. You will also refine and create Bounded Context Canvases to fix some of the design problems you identify.

After this workshop, you will know how to visualise the design Bounded Contexts and you will know how to critique a design and explore alternative modelling choices.


Part I - Advanced Bounded Context Design With The Bounded Context Canvas

In this session we take a deep-dive into Azure Machine Learning, a cloud service that you can use to track as you build, train, deploy, and manage models. We use the Azure Machine Learning Python SDK to manage the complete life cycle of a PyTorch model, from managing the data, to train the model and finally run it into a production Kubernetes cluster.

At the end of this session you have a good grasp of the technological building blocks of Azure machine learning services and train a PyTorch model on scale.

Build and deploy production ready PyTorch models

Machine Learning

Microsoft

With the new spec release, GraphQL strengthens its type system with more capable interfaces and allows for pipelining features through repeatable directives. Moreover, we are finally getting support for @stream and @defer in modern GraphQL Servers that take full advantage of async iterators.

This talk will explore how to take advantage of these new capabilities and how to build a next-generation mobile-first, cloud-first GraphQL backend with the revamped ASP.NET Core 6 web stack.

Building modern applications with GraphQL 2021 and beyond in ASP.NET Core 6

This talk will cover my frameworks & workflows to bring together technical knowledge with communication, problem solving and creativity to reach business outcomes with AI/ML and Data.

For extra context, we'll also apply these frameworks to some real-world use cases from Blackbook.ai, so the audience can understand how to put things into practice.

Realities & Misconceptions about Enterprise Applications of AI/ML and Data

Big Data

We will walk through the whole process! Starting from writing and debugging your Blazor app and Functions API, we will also unit test our front and back-end and glue them together with the authentication service emulator for local development. For CI/CD and service management needs, like staging environments and user invitations, we will conclude with a scalable build pipeline that can be flexibly reused for your future projects!

Come to this talk when you want to improve your development process with the best tooling and focus on the business value of your app!

Developing and Deploying a Static Web App with Blazor and Azure Functions

DevOps

Serverless

Tools

In this session, Laurent Bugnion, a Cloud Advocate working with Microsoft will share his recent journey discovering the basics of Deep Learning. We will not make data scientists out of you, but we will enable you to understand what people talk about when they mention artificial intelligence. We will see how Azure can help you with tools, services and machines. Last but not least, we will also have a discussion about the ethics of AI and what we should be careful about.

A gentle introduction to Deep Learning

In this session, we will demonstrate use of latest functional additions to C# - records, tuples, deconstruction, nullable reference types, LINQ, extension methods, and a few others - which will be integrated with object-oriented and even procedural elements into a unified design which effectively solves a practical problem.

Mixing Paradigms Using the Latest C# Language Features

Functional Programming

In this talk we will go through our learnings of doing Open Source at a company with thousands of engineers. The focus will be primarily on producing open source software rather than on using it.

How we improved the open-source release cycle from almost a year to a few days

Providing an on-road experience for Open Source across the company

Moving from 10+ GitHub organisations to a single one

Why your legal and security counterparts are your friends and how you can best work with them

Open Source at commercial organisations

Open Source

planed the new system so that it fully replaced all old ones, leaving no holes;

were at any time sure what would be the next piece of software that we need to develop;

released new functionality in small portions that were immediately taken in use without necessity to wait for some other piece to be ready;

met the deadlines in spite of additional complications caused by the pandemics.

This was not just luck. It was the result of application of a methodology that ensures this very result: product that covers end-to end flow, minimal releases and clear priorities. In this case study I will show how this methodology works.


Change wings on the fly: replace a system that handles 50 million euro turnover with zero downtime

Things can be in many states at once (superposition), objects can instantaneously affect each other or we can even teleport their state (entanglement), objects can behave as both particles and waves (wave-particle duality) and probabilities appear to be built into the very fabric of reality. In this talk, we will explore these bizarre concepts of quantum mechanics using quantum programs authored in Q# and a computation theory fundamentally different from what we know from regular computers.

The Bizarre Quantum World with Q# and Azure Quantum

In this code-focused tour, we’ll systematically analyze the test scenarios we want to build, then live-code mocks in two scenarios: Express and Vue. It’s easy to gain value and speed once you know how.

Mocking in Front-end and Back-end TypeScript Tests

JavaScript

Testing

While many Open Source projects have amazing code-bases, the Readme and documentation are letting them down and as a result, they are losing influence and opportunities for adoption and feedback.

In this talk, Ben uses his expertise in building an Interactive Learning Platform to highlight The Art of Documentation and the Readme file. The aim of the talk is to help open source contributors understand how small changes to their documentation approach can have an enormous impact on how users get started.

Defining technical details in an accessible way

Building documentation that encourages users to get started

How to manage documentation and keep it up-to-date and relevant

In the end, attendees will have an understanding of how to build beautiful, useful documentation. This will be backed by examples from some of the best open-source projects.

The Art of Documentation and Readme.md

Programmable Software Architecture

These modern applications typically also need authentication and single-sign-on as well as token-based security for calling APIs – in other words OpenID Connect and OAuth 2. There are different patterns for securing such applications and this session covers some of the pitfalls of the various approaches, especially given the ever-changing browser landscape. We will conclude with the “backend for frontend” (or BFF) pattern which has become the most secure and stable of these approaches.

Securing SPAs and Blazor Applications using the BFF (Backend for Frontend) Pattern

Security

This talk looks at the essentials you should know about, if you would enter the OAuth ecosystem today. Which protocol flows and extensions should you study, which “dialects” like OpenID Connect are important, and if you decide to dive deeper, what would that “recommended reading” list look like?

OAuth – the good Parts

You can decrease the time you waste reading complicated code by writing code that's easy to read - code that fits in your head.
Code should fit in your head at all levels of abstraction. At the entry point, at the business logic level, and at the lowest levels of detail. This is fractal architecture - code that is organised according to that principle of self-similarity.
Key to achieve fractal architecture are encapsulation, aggressive thresholds, and referential transparency. Code examples will be in C# - written in a style also readable to developers working in Java, TypeScript, C++, etc.

Fractal architecture

Cross-Platform

The impact open source can have on your applications

Examples: Obviously everyone is talking about Log4j but there may likely be more examples by April

How to choose the best open source package

Known vulnerabilities (and the severity thereof) - where there’s smoke there’s fire. 

Nested dependencies and the trouble they can cause

Secure Open Source Practices

In this session, we'll look at anemic, procedural, boring code and examine code smells that can point us in the right direction. We'll also look at standard design patterns for more complex behaviors and models, and how to recognize when (and when not) to apply them. Finally, we'll cover how to safely apply refactoring techniques to achieve our domain-driven model nirvana.

Domain-Driven Refactoring

What's the difference between mentorship and sponsorship and how does that build successful teams? What's the role of the senior engineer as a colleague to an early-in-career engineer? What's the difference between learning how to code and learning how to think about systems? What must we do to welcome the next generation of creators, and what are your responsibilities? 

Let's facilitate a welcoming culture of learning and exploration and normalize not knowing the answer!

Keynote: Building Teams Through Systems Thinking and Stories

This technical talk will discuss the requirements analysis, and dozens of decision points that need to be made to move this into a sustainable future. We will discuss the complexities of moving legacy systems into the cloud, considering operating systems, platforms, open source code, testing, DevOps, and much more.

Moving 17 years of old legacy code and sites into the Cloud

This talk provides defensive instruction in relation to the OWASP Top Ten to aid developers in authoring secure software.

-Identification and Authentication Failures


-Security Logging and Monitoring Failure


The OWASP Top Ten 2022 Release

In this talk we'll address new defensive strategies such as modern JavaScript framework defense in Angular, React, Vue and other frameworks. We'll also look at how CSP deployment has changed in the past 7 years illustrating the progressive use of content security which supports CSP v1, v2 and v3 concurrently. 

We will then look at advances in HTML sanitization on both the client and server and focus on sanitizers and defensive libraries that have stood the test of time in terms of maintenance and security. We'll also look at interesting design topics such as how HTML injection is still critical even in the face of rigorous XSS defense, how HTTPOnly cookies are largely ineffective, and how Trusted Types is making your favorite frameworks more secure. 

This talk should help developers and security professionals alike build a focused and modern strategy to defend against XSS in modern applications.

The Last XSS Defense Talk

Join Richard Campbell as he looks back through the evolution of rapid development tools, the growth of the internet, mobile technology, the emergence of cloud technologies, open-source, and all the elements of the past twenty years of development that speak to a future that's hard to imagine!

Looking Back - The Last Twenty Years of Software Development

Languages

Mobile

In this demo-centric talk, Microsoft developer/architect Steve will show the current state-of-the-art in Blazor for building rich web-based UI for browsers and native apps. This will include powerful new features shipped in .NET 6, as well as upcoming enhancements under development for .NET 7 and .NET MAUI. We’ll also look at more experimental future possibilities, including running .NET Core on WASI (WebAssembly on the server) which creates entirely new cloud and edge hosting options and lets you bring .NET code to places it’s never been before.

What’s next for Blazor, and .NET on WASI

Let's explore what's new in C# 8, 9 and 10!

We will look at how the language has changed and why these changes to the language will make us better C# developers, with less bugs in our code.

Pattern Matching in C# 8 and the updates made to it in C# 9

What's new in C#? Exciting new features in C# 8.0, 9.0 and 10!

In this workshop, you will work through scenario-based activities in groups. Each scenario will provide the design of one or more Bounded Contexts as Bounded Context Canvases. In small groups, your challenge is to review the design by identifying the positive and negative design choices, and flagging up areas of the design that need further attention. You will also refine and create Bounded Context Canvases to fix some of the design problems you identify. After this workshop, you will know how to visualise the design Bounded Contexts and you will know how to critique a design and explore alternative modelling choices.

Part II - Advanced Bounded Context Design With The Bounded Context Canvas

Most .NET developers are familiar with the use of Linq, and basic constructs such as IEnumerable, Func delegates, arrow functions and ternary expressions, but did you know that you can use all of this to implement some of the most powerful patterns and techniques from the world of functional programming?

This talk will demonstrate how, using only familiar features available in out-of-the-box C#, to write Functional code that is:

* More robust
* Easier to read
* Easier to maintain

As well as these benefits, Functional code is a great enabler for the use of concurrency with Async functions and Serverless applications with technologies such as Azure Functions.

This talk might be of interest to anyone looking into moving to a new platform, or in improving the scalability of an existing application, or even just interested in seeing what Functional Programming is all about, but all within the comfort of a familiar language.

We might even attempt the impossible, and explain what a Monad is!

Functional Programming with C#

In this workshop we will introduce Uno Platform app development and build your first fully cross-platform app in C# and XAML.

Part II - Building cross-platform apps with Uno Platform

In order to test proactively as opposed to reactively, try testing in production! You will have an increased accuracy of test results, your tests will run faster due to elimination of bad data, and you will have higher confidence before releases. This can be accomplished through feature flagging, canary releases, and data cleanup. You will leave this talk with strategies to mitigate risk, to better your understanding of the steps to get there, and to shift your company’s testing culture, so you can provide the best possible experience to your users. This talk is beneficial because too many people are stuck in the old mindset of testing their features in a staging environment. At the end of the day, we don't care if your features work in staging, we care if they work in production.

Testing in Production

In this session I will tell you how I built a working IoT system in a short time and no budget and we will talk about pitfalls and important considerations in IoT systems

Smart home from scratch - a little C#, a little C++  and a whole lot of cheap Chinese electronics

The building of Project Enabled Play - a platform built in .NET that enables users to turn their voice into gaming controller on any platform they have access to. Come learn about scaling applications in .NET to over a dozen different platforms and channels while building for accessibility to even the playing field. Gain an understanding of voice and conversational platforms, real-time communication technology, and best practices for sharing code and going from PoC to product.

Try your shot at landing a win in Call of Duty, Fall Guys, Minecraft, and more using your voice, then leave with a working knowledge of other ways you can use .NET and the tools you're familiar with.

Making Every Game More Accessible with .NET and AI

Gaming

Streaming isn't a new concept. You request a resource, but rather than wait for the resource to arrive in its entirety before processing it, you process it in chunks as it arrives over the wire. On the web, this leads to faster rendering. When applied to service workers, this involves placing the markup for common user interface elements of a page in the service worker cache, then combining and streaming that cached markup of the page with markup from the network.

The results are more compelling than you might think, and the end result is a faster and more resilient experience for more people in more situations, and can substantially improve performance even in places where network connectivity is scant. In this session, you'll find out how to apply this technique, and see how it can improve the user experience.

Now THAT'S What I Call Service Worker!

While the classical models still work and have their own merits, some of them rely heavily on documentation, extensive coordination between teams or code-sharing. We use shared libraries, and over time our projects become intertwined with dependencies. In these cases, we need something to untangle those and reduce coupling. Welcome gRPC.

gRPC has been around for a while and .NET Core 3.0 welcomes it as a first-class citizen. It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server, to bi-directional streaming out of the box.
In this session, we will look at how to use gRPC and its 4 models and what are the benefits and or downsides of using gRPC compared to the traditional models.

Embracing gRPC in .NET

Culturally there is a huge gap between the people who are using the cloud and the ones who are tasked to manage it. The tug of war is tedious but still important to maintain a balance between speed and efficiency. But as the business grows and cloud deployments get more complicated, the balance is tipped against cost efficiency.
We believe there is a gap in our technical stack, team culture as well as business processes to solve the cloud efficiency challenges. In Farfetch we have built ICON (Infrastructure Cost Optimized Now) to bring cloud cost in the centre of our engineering practices. In this talk I would cover the product features, impact on our cloud cost and the future roadmap of this work.

How Farfetch is facing the Cloud cost challenge

People

In this session I will introduce you to the beautiful world of Minimal APIs. I will show you how easy it is to build an API using them, with just a few lines of code, compare it to the "old-fashioned" approach within .NET in both amount of code and performance and see how it stacks up against other languages and similar frameworks. I will also show you how you can give them structure and how you can organise them, test them and use them in the real world.

Goodbye controllers, hello Minimal APIs

Reliability for systems means that they are doing what their users need them to do. A system's reliability is essentially how happy users are and we know those happy users are good for business. If reliability is one of the most important requirements of any system, users determine what reliability means, and it’s okay to not be perfect all the time. We need a way of thinking that can address this way of thinking since we have limited resources to spend, be they financial, human, or political.

Relia...bility?

I might agree with that, while remembering that everything comes with a price. This session is a summary of my experience with ES gathered while working on 3 different commercial products. Instead of theoretical aspects, I will focus on possible challenges with ES implementation. What could explode (very often with delayed ignition)? How and where to store events effectively? What are possible schema evolution solutions? How to achieve the highest level of scalability and live with eventual consistency? And many other interesting topics that you might face when experimenting with ES.

Event Sourcing - what could possibly go wrong?

In the past 4 years, I have been leading the DevOps transformation across many teams in our organization. I have modeled processes, built tools, led discussions, sessions, workshops. I have pushed and been pushed in different directions. I have seen it all.

I want to share that experience with you. I want to share what are the biggest challenges we faced. What personas I have encountered in the process and how I have dealt with them. I want to show you that it is not all sweets and roses, but it is also definitely not a suicide or a dead end.

I will try to summarize my list of things you need to keep in mind, in order to be successful in that journey. I will share what we did wrong and what we did right. Where it hurts and where it shines.

DevOps is cool and cruel at the same time. This is what makes it so fun and also what makes it work.

DevOps transformation – the good, the bad and the ugly

Bring your questions as there will be plenty of time for Q&A.

NuGet: things you didn't know

When I was given my first technical team to lead many years ago, I didn’t know what to do. I copied the style of technical leads I worked with and what I could learn by reading USENET newsgroups about leadership (yes, it was that long ago). The results were mixed, and I felt that I was constantly making it up as I went along. However, after I began leading projects that used Agile software development, I eventually realized that the principles behind Agile provided powerful guidelines for leading my teams! These principles made me a more effective leader, increased team morale, and improved my ability to deliver software to customers.

This session will help attendees understand the principles behind the Manifesto for Agile Software Development and how to practically apply them to their daily leadership practices.

* The Hero-Developer’s Journey
* Remembering the Revolution
* Individuals and Interactions: Preserve Dignity and All Costs
* Working Software: Working Always Ships Faster than Perfect
* Customer Collaboration: Customers Trust Colleagues, Not Contracts
* Responding to Change: Don’t Fear Surprises, Fear Inflexibility

Leadership Lessons from the Agile Manifesto

In this practical half-day workshop, you’ll learn everything related to GitHub Actions:

Workflow runners (hosted and self-hosted)

Variables, secrets, contexts, and expressions

Actions: JavaScript/Typescript, Docker, and Composite Actions

Hands-on: My first multi-stage pipeline with approvals

Security considerations when using GitHub Actions

The workshop is designed for developers and DevOps engineers that are experienced in other CI/CD platforms, like GitLab, Jenkins, or Azure Pipelines, and want to switch to GitHub Actions. But people that are completely new to the topics will also be able to follow along.

Part I - From 0 to hero: GitHub Actions kick start

But even then – working with device hardware still requires not only error-prone platform-specific code but also developers familiar with each of the target platforms to maintain it. What if there was a framework, which would allow you write all your code in C# and XAML, with unlimited styling and templating capabilities, and a single API to access device hardware and APIs? And what if you could use this framework to target all mobile and desktop devices and even the web? Meet the Uno Platform - your C#/XAML apps on Windows, Android, iOS, macOS, Linux, and WebAssembly!

Uno Platfrom: Your Apps Everywhere

Part I - Building cross-platform apps with Uno Platform

This is why Durable Functions were developed.
With Durable Functions, you have even more power to create powerful backend systems. You can have long running functions, massively parallel processing, and other application patterns that we will review and demo. But all this power comes with some caveats, and it is very important to understand precisely how Durable Functions work, and what the underlying mechanisms are. In this session, Laurent Bugnion, a Microsoft Cloud Advocate since 2017 will take you to a deep dive into Azure Durable Functions. You will get out of this talk with a deeper understanding of Azure Functions, the Durable extensions and some demos illustrating all the points.

Deep dive into Durable Functions

This is "ChatOps". ChatOps is a collaboration model that connects people, tools, processes, and automation into a transparent workflow. It's the bridge that connects the work that is needed, what is currently running, as well as what has been done - utilising real time communication channels to keep you updated every step of the way. It started life at GitHub, where they created Hubot and found it brought them huge efficiency benefits.

Collaboration is critical in DevOps. According to Gartner [1], 75% of DevOps initiatives fail "due to issues around organisational learning and change". ChatOps addresses that through a focus on collaboration and information sharing. This is why we have it as a key practice in our Garage Methodology [2]. It's also why we see many other businesses turning to ChatOps as a more collaborative and efficient way to perform operations. Instead of just using a traditional help ticket tool, DevOps experts use instant messaging collaboration tools like Slack to communicate - not only with each other, but also with the tools they use to do their jobs.

In this session, we want to get you thinking about whether adopting elements of ChatOps could improve your DevOps workflow and give you practical tips to get started.

To help give you some ideas for what you can do with your own application, we'll show you a demo using Apache Kafka - it's a nice simple example of a microservices application, plus it already has instrumentation and monitoring hooks. We'll show how to get a Kafka cluster to post messages to your team Slack channel when there is something that a dev-ops person should be be looking at. And we'll give an example of how to perform simple Kafka admin tasks from Slack.

 https://www.gartner.com/smarterwithgartner/the-secret-to-devops-success

https://www.ibm.com/garage/method/practices/manage/chatops


ChatOps: Why you should give your application a voice

In this talk I’ll explain why caring for your team shouldn’t be unique to just your manager, and how it could make you a better professional.
We will cover the challenges and advantages that you could face, and also share practical tips to help your peers thrive in their work.

Supporting your peers' growth as a tech lead

In this talk we will go through our approach to building tools for reliability engineering.

The first part will touch upon:
- Buy vs build vs open-source decisions
- Local vs global maxima - providing an on-road experience with a single platform and common tools
- Feedback loop between tools, teams, and events such as incident reviews and GameDays

The second part will focus on two of our projects; an automated region failover capability and chaos engineering. We will present our work and any learnings so far. Designs and architectures, technical challenges, the importance for good developer experience, challenges for adoption, and more.

Scaling Reliability Engineering with Tools

In this talk, you will learn how to bring the power of Tailwind CSS to your Blazor applications. We’ll start off with an introduction to Tailwind and how it differs from other CSS frameworks. Then we’ll get into some code and see how we can integrate Tailwind with Blazor. For the rest of the time, we’ll explore the various features of Tailwind and see how just how beautiful we can make our Blazor app!

Building beautiful Blazor apps with Tailwind CSS

However, how do you enable this new audience to get access to your streaming data? It’s not feasible, nor is it desired to expose internal channels, such as Kafka topics, externally. One could build custom applications with hand-crafted logic to enable access, but this is not without its own drama, from adapting to changes in the data, to signing on new users to the service.

So, how can we, in a relatively short amount of time, build something that will allow us to serve up consumable streaming data, with the flexibility to not only keep internal and external systems separated, but also manage security and access?

By using API management as part of your streaming architecture, you will be able to achieve just this. In addition, API management offers many other advantages, such as:
- Lock down endpoints with appropriate, modern security approaches
- Work with access policies shape and control how often and when your API can be called
- Modify the data in-flight both for incoming events, as well as outgoing ones

In this talk we will look at API and access management, how they work together, as well as discuss in detail what API management will enable you to do when it comes to event-based information exchanges.

Achieving great API-ness. Why streaming and API management go hand in hand

We'll dive deep into the objects folder, unpack commits, look at the types of DAG nodes, examine object content, and build a complete visualization of the stored content. We'll also quickly look through Git hooks, Git config, and ref logs. Come experience the zen of git.

The definitive deep dive into the .git folder

Fortunately, the situation today is dramatically different to a scant few years ago, let alone a decade or two: the same technologies that enable SaaS have also radically transformed on-prem deployment. Modern tools like Docker, Consul, ELK and Kubernetes - to name a few - can be leveraged to completely transform the experience for both customers and vendors. In this talk we'll contrast the challenges and advantages of SaaS and on-prem, see how things have evolved in recent history, and see how modern on-prem deployment can be, if not pleasurable, at least relatively painless.

Not your Grandmother's On-Prem

Continuous Delivery

Docker

In the early 1970s J Paul Morrison invented Flow-Based Programming, a model in which a system was comprised of a number of applications communicating asynchronously through flows of discrete information packets. Flow-based programming designs around the idea of a graph of applications through which data flows.

Few engineers now are aware of Morrison's insights, so in this session we will explore Flow-Based Programming as a tool to help us model event-driven architectures. We will explain the basics of Morrison's model, demonstrate how it has been used in Flow-Based Programming, look at the insights it gives us for Event Driven Architectures and demonstrate its usage in that context.

NDC { Porto }

Agenda

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

Keynote: Building Teams Through Systems Thinking and Stories

Scott Hanselman

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

Programmable Software Architecture

Scott Haney

Secure Open Source Practices

Jillian Ratliff

A gentle introduction to Deep Learning

Laurent Bugnion

Part I - Advanced Bounded Context Design With The Bounded Context Canvas

Maxime Sanglan-Charlier

Nick Tune

The OWASP Top Ten 2022 Release

Jim Manico

The Art of Documentation and Readme.md

Ben Hall

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

What’s next for Blazor, and .NET on WASI

Steve Sanderson

Mocking in Front-end and Back-end TypeScript Tests

Rob Richardson

Build and deploy production ready PyTorch models

Henk Boelman

Part II - Advanced Bounded Context Design With The Bounded Context Canvas

Maxime Sanglan-Charlier

Nick Tune

Implementing async with coroutines and fibers - project Loom in C#

Adam Furmanek

OAuth – the good Parts

Dominick Baier

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

Fractal architecture

Mark Seemann

Securing SPAs and Blazor Applications using the BFF (Backend for Frontend) Pattern

Anders Abel

Change wings on the fly: replace a system that handles 50 million euro turnover with zero downtime

Tatiana Kolesnikova

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

Developing for Linux on Windows with WSL and Windows Terminal

Scott Hanselman

Developing and Deploying a Static Web App with Blazor and Azure Functions

Matthias Koch

Building modern applications with GraphQL 2021 and beyond in ASP.NET Core 6

Michael Staib

Realities & Misconceptions about Enterprise Applications of AI/ML and Data

Brooke Jamieson

Come listen to me, I’m a fraud! A story on success, impostor syndrome and self-inflicted, perpetuall

Joep Piscaer

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

Domain-Driven Refactoring

Jimmy Bogard

What's new in C#? Exciting new features in C# 8.0, 9.0 and 10!

Filip Ekberg

Cost cutting strategies for Azure Cosmos DB

Hasan Savran

The Last XSS Defense Talk

Jim Manico

Mixing Paradigms Using the Latest C# Language Features

Zoran Horvat

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

Moving 17 years of old legacy code and sites into the Cloud

Scott Hanselman

Looking Back - The Last Twenty Years of Software Development

Richard Campbell

Share Pie: The DDD Treasure Hidden in Plain Sight

Nick Tune

Open Source at commercial organisations

Nikos Katirtzis

Daniel Albuquerque

The Bizarre Quantum World with Q# and Azure Quantum

Filip w