YAML is Awful ... Except for Everything Else

Can't get your head around YAML? Always failing to solve the linting errors without kicking the build again for the umpteenth time? Let's compare and contrast JSON and YAML, and really understand what makes YAML awful ... and great.

The Culture of Python

In this talk we don't look at the syntax of Python. Though that's interesting, that's the easy part. In this talk we look at the culture of Python. What libraries should we look at for hosting a web api? What libraries would we use for data access? For data science? For script automation? Where do I download these packages? We'll focus a lot on Jupyter, the interactive REPL that allows you to quickly sketch and experiment in Python. We'll use Jupyter to play with Python functions, to do data transfer, to build runbooks-as-code, and to evaluate and plot data. Finally we'll take a Jupyter notebook and convert it into a REST API that one can consume from any app. Along the way we'll also look at running C# and JavaScript inside of Jupyter. Getting started with Python can be fun and rewarding, and open up a whole new set of skills and solutions.

The Science and Art of Building RunBooks

How much information is too much? When is it not enough? Are the runbooks up-to-date? Are they used? Do you even have any? Let's discuss the methodology of building runbooks for solving known issues, and the process for keeping this information relevant. We'll coin the term remediation-as-code, and see how Jupyter makes runbooks continuously relevant.

Testing in ASP.NET Core with XUnit and MoQ

ASP.NET Core has been designed from the ground up with testability in mind. XUnit is the testing framework the ASP.NET team uses to test their own code. Let's add some tests to a sample ASP.NET Core project, and see how easy it is to strip away dependencies not necessary for the test.

Terraform + DevOps = GitOps

Terraform is great at ensuring consistent infrastructure is in place, and managing drift when it isn't. DevOps creates automation around common processes. When we stick Terraform, Git, and DevOps automation together, we get GitOps. Let's leverage GitOps to ensure we have configuration-as-code, and that our environments always match our expectations. Join us for this journey of getting started with GitOps.

Serverless Architecture in Azure

AWS has Lambda, Azure has Azure Functions, Web Jobs, and App Service. Whether you want to script pay-by-the-drink web endpoints or build more traditional micro services. Come join us for this code-focused look at architecting, coding, and deploying serverless resources in C# and .NET Core.

Scaling the Testing Pyramid in TypeScript

Unit tests? Integration tests? Mocks? Stubs? Fakes? How does this apply to the web? Let's look at all the ways you can test a web app and demo all the tools you'd use. We'll live-code most tests to show you exactly what makes a good testing strategy. You'll leave with a GitHub repo you can use to keep learning or fork and use in your own PWAs.

Planning for the varied levels of once-data-processing

In pub/sub and event sourcing, we have at-least-once and at-most-once processing. Each have their place, but each have their drawbacks. What if we could have exactly-once delivery? Let's compare and contrast the use-cases for each, demo each in action, and see if exactly-once delivery is the right fit for your business.

Live-code a Dockerfile

In this session I’ll begin with an empty folder and a terminal, and live-code everything. I’ll then build and run the container. New to Docker? You’ll learn how here.

Kubernetes Test Drive

Are you a Docker aficionado or are you new to the Docker ecosystem? Come see how Kubernetes (K8s) adds a mature solution for running containers in production and development. We'll start with containers, layer in pods, replica sets, deployments, and services. We'll dig into minikube and kubernetes in docker desktop. You'll leave with a solid understanding of the principles of K8s, and a practical set of skills for driving this container orchestrator throughout the software development lifecycle.

Kubernetes for the Docker Developer

So you've gotten good at Docker, and you're ready to take it to the next level. Come see how Kubernetes (K8s) adds a mature solution for running containers in production and development. We'll start with Docker containers and Docker compose files, and we'll layer in pods, replica sets, deployments, and services. We'll dig into minikube and kubernetes in docker desktop for local work, and managed cloud K8s on Azure. You'll leave with a solid understanding of the principles of K8s, and a practical set of skills for driving this container orchestrator throughout the software development lifecycle.

JavaScript the Grumpy Parts

We love JavaScript, but we must admit: it's weird. Why does `this` behave as it does? How does variable scope work? Why do we have such comical behavior when comparing mixed types? Let's pull back the covers of these scenarios, and learn how it truely works. You may find a new reason to fall in love with JavaScript.

JavaScript Async Deep-dive

Callbacks, promises, async, oh my! Asynchrony in JavaScript has come of age. We'll start with a quick history of the 3 techniques. Then dive in deep to async and await. How can you transition from callbacks to promises or promises to async? How can you use legacy code with await? How can your legacy code call your async functions? Whether you're using Babel or evergreen browsers, as Yoda would say, "async code write you can."

How to Automate Your Processes with Bash

Are you tired of working harder and want to work smarter instead? Is there a process you're constantly doing that is repetitive and timeconsuming?

Automating with API calls and bash commands can help you streamline your workflow.

As SRE front-line workers, we spend a lot of time toiling away at manual tasks. "Can't we automate this?" "Well, it isn't constant enough" or "I don't know how" are the most common objections.

You don't need to work harder, you need to work smarter and in this session, I will show you how.

Horizontal Autoscaling with Kubernetes

Now that the app is running in Kubernetes, how do we scale it to meet demand? What metric should we use? CPU? Requests? something else? Let's dig into why we auto-scale, and how we auto-scale with lots of examples. Finally we'll look at potential pitfalls and gotchas like how to scale to 0 and how to avoid scaling too big for your budget. Come learn how to scale with Kubernetes.

Getting Started with Jupyter

Jupyter notebooks are a great way to document processes and keep them relevant with automation. Can you leverage Jupyter for incident response and system documentation? Join us for this session as we crack open Jupyter and get familiar with automating common tasks.

From Build Script to a Dockerfile

The quest of CI/CD is a uniform build in a neutral environment. With Docker's multi-stage builds, you can get lean production images while ensuring software quality metrics, and bundling optimization is done exactly right each time. Join us on this journey from a traditional build script to a Docker build that versions, builds, tests, and deploys your software. You can upgrade your infrastructure today.

Docker for Windows Container Development

Docker is carefully tucked between virtualization, continuous deployment, and pure awesome, available for Linux and Windows software development. ASP.NET Core is a cross-platform, high performance and open-source reimagination of the Microsoft stack to build modern applications. In this session you will get the basics of Windows containers and getting started with Docker Desktop integration with Visual Studio to both start building new .NET Core apps and enabling Docker support for legacy .NET Framework apps in containers. You’ll leave with the tools you need to Docker-enable your .NET workloads.

Developing with HTTPS in Containers

HTTPS is the new black. In production, you'll likely terminate HTTPS at the load balancer. But how do you develop HTTPS content inside Docker containers? Do you just drop back to HTTP and assume it'll work out? Do you drop the Docker part until you commit? How do you we get the browser to trust the self-signed certificates inside Docker containers? Let's dive deep into certificate trust, how Linux stores certificates, and how web servers use certificates. With that knowledge in place, let's build up Docker containers for both development (self-signed) work, and containers that have real, trusted certificates should you choose a Layer-4 load balancer in production.

Database DevOps with Containers

Unlike CI/CD pipelines for applications, we can't just delete the database and pop up a new one with each new version. Let's start with the production database, and get SQL Server content to developers in containers, and then flow schema and lookup data back into production with migration tools. You can bring the reliability and automation of CI/CD pipelines to Database DevOps with containers.

async and await with Node and Express

Express is the defacto Node web server, but it's built with callbacks. Can we use modern JavaScript like async and await? Let's dive into building routes with modern JavaScript, and how to write tests that prove they work.

Async Python, Good it is

Have you loved async & await in JavaScript and other languages? Wished you could add it to your Python? async.io is here! Now with async & await we can think synchronously and run asynchronously. But there's some sharp edges and edge cases. Let's look at how easy it is to do multiple tasks at once, and how we collect all the results. We'll also look at best practices and edge cases like how do you kick off an async process from main?

ASP.NET Dos and Don'ts for highly maintainable code

What is legacy code? Did I just write more of it? ASP.NET rebooted itself to make it more maintainable and performant. Let's learn to build highly maintainable code as well. We'll look at the low-hanging fruit to get you on a path to avoiding the common pitfalls and reach for the easy wins. You can avoid legacy.

A Database DevOps Pipeline

Are your automation practices accounting for the database? How do you verify database software quality? Most importantly, how do you care for customer data as the schema evolves? Let's dig into building a CI/CD pipeline for databases. We'll leverage Red Gate tools and containers for automation, testing, and push-button deployment. You can bring DevOps to the database.

.NET Testing Best Practices

ASP.NET Core has been designed from the ground up with testability in mind. XUnit is the testing framework the ASP.NET team uses to test their own code. Let's add some tests to a sample ASP.NET Core project, and see how easy it is to strip away dependencies not necessary for the test.

Your Technology Your Way: Full-stack Web and Service with .NET and Node

Do you want to build full-stack with your stack? We'll build an ASP.NET website using Blazor and WebAPI, a back-end service using Service Worker and gRPC. Then we'll build the same website with Node using Express, Vue.js, gRPC, and PM2. Along the way we'll compare and contrast these technologies to empower you to use JavaScript or C# front-to-back for your next project. You'll leave with a functional sample in each, and a methodology to choose your next full-stack site.

Vue.js and TypeScript: Working Together like Peanut Butter and Jelly

Have you struggled to get TypeScript and Vue to play well together? Me too. Vue is a fantastic SPA framework, and TypeScript is a great way for catching errors faster. Together, they can boost your productivity. Join us as we peel back the layers of TypeScript and look at the tricks of the trade to get them playing well together. You'll leave with a solid methodology and code samples to get started with Vue + TypeScript.

The definitive deep dive into the .git folder

What's in the .git folder? How are commits stored? How do branches work? 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.

Service Mess to Service Mesh

In our quest to secure all the things, do we jump in too quickly? We'll use Istio and Linkerd as example service meshes, and look at the features we would expect from a service mesh. We'll dive into the day-1 experience with both Istio and Linkerd, and some advanced scenarios of using the service mesh. We'll compare this to border security with an app gateway, and compare and contrast the security features, complexities, and implementation costs. You'll leave with a concrete understanding of the benefits and tradeoffs you get when you pull in a service mesh, and be ready to justify the investment.

Securing Docker Containers: Kubernetes just handles that, right?

Securing a container is like securing a virtual or physical machine. You need to understand what's installed, ensure it's patched, and reduce the attack surface. But unlike traditional servers, this is done at build time for containers. Journey with us as we build a comprehensive strategy for securing your digital assets that run in Docker, and leave with concrete steps you can apply to your DevOps pipeline today.

Redux: the MVC framework for data

The MVC Pattern provides elegant abstractions for web requests. Redux provides similar patterns for data movement in React. Angular has RxJS and Vue has VueX with similar patterns. Let's dig deep into the way data flows through the Redux, demo strategies to get started, and look at ways to debug and troubleshoot it when things go wrong. You'll leave with a solid understanding of the Redux pattern and appropriate times to use it.

Post jQuery

jQuery was a wonderful tool that paved over the irregularities of browsers and offered a simple interface for making very powerful applications. Today with evergreen browsers and modern JavaScript, we no longer need this crutch. Let's look at our favorite jQuery techniques like $.ajax() and $(...).click() and $(...).addClass() and compare this to the code we'd write in modern JavaScript. Sprinkled in are great ES6 techniques like rest and spread, promises and fetch. Challenge yourself on your next project to see if you can run in a post-jQuery world.

Mocking in Front-end and Back-end TypeScript Tests

When the goal is unit testing, it's common to swap out dependencies with fake pieces to give more control and to make tests run faster. 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.

Minimal APIs in ASP.NET 6.0

With ASP.NET 6.0, there's a 4th coding paradigm joining MVC, WebAPI, and Razor Pages: Minimal APIs. It's a great way to create the lightest weight microservice. But are you trading everything for the small surface? We'll start with a .NET 5 project and build up to a Minimal API looking at a bunch of brand new C# 10 features along the way. Like the other 3, this is not an either/or choice, and when it makes sense, you can be really productive here too.

Local Development Techniques with Kubernetes

It's day 2. The corporate k8s cluster is humming. And our local dev story is interesting, but how do we connect the wires? Can we automatically rebuild cluster resources when code changes the same way we watch files and rerun unit tests? Can we optimize the container development workload for developer joy? Can we debug software running in containers? Let's look at Helm, Skaffold, Minikube, docker-compose and other developer-time tools to boost our productivity. You can definitely optimize for developer joy. Come be more productive.

Kubernetes Test Drive

Are you a Docker aficionado or are you new to the Docker ecosystem? Come see how Kubernetes (K8s) adds a mature solution for running containers in production and development. We'll start with containers, layer in pods, replica sets, deployments, and services. We'll dig into minikube and kubernetes in docker desktop. You'll leave with a solid understanding of the principles of K8s, and a practical set of skills for driving this container orchestrator throughout the software development lifecycle.

Kubernetes hands-on (Workshop)

Kubernetes is how you run Docker in production. Bring your laptop with Docker for Windows or Docker for Mac edge version installed. We'll walk through getting a K8s cluster fired up on Docker-Desktop, minikube, and on Azure. You'll be hosting Docker containers in development and production in no time. We'll dig deep into:

- A quick tour through Docker concepts
- The components of a kubernetes cluster
- pods, services, deployments, and replicas
- ways to scale and expose/isolate your containers
- public and private container registries
- stateful containers
- promoting from development to production
- Azure Container Service (AKS)
- Best practices for building at cloud scale
- Tips & Tricks for leveraging Docker and Kubernetes
- When not to use Kubernetes

We'll look at the commands and ecosystem around building infrastructure as code, local and cloud clusters, and best practices with containers. Come see why devs and ops love Kubernetes.

JavaScript the Grumpy Parts

We love JavaScript, but we must admit: it's weird. Why does `this` behave as it does? How does variable scope work? Why do we have such comical behavior when comparing mixed types? Let's pull back the covers of these scenarios, and learn how it truely works. You may find a new reason to fall in love with JavaScript.

JavaScript Tests in Node, the Browser, and CI

Good software practices don’t end just because you’re building a thick client in the browser. The JavaScript community is a flourishing boutique of high-quality tools and techniques. We’ll dig into some of the more popular open-source JavaScript patterns that have emerged from the Node community. We'll see mocha, chai, karma, phantom, and travis in action, look at some great techniques and patterns for browser development, and brush up on things that make JavaScript a phenomenal place to work.

JavaScript Async Deep-dive

Callbacks, promises, async, oh my! Asynchrony in JavaScript has come of age. We'll start with a quick history of the 3 techniques. Then dive in deep to async and await. How can you transition from callbacks to promises or promises to async? How can you use legacy code with await? How can your legacy code call your async functions? Whether you're using Babel or evergreen browsers, as Yoda would say, "async code write you can."

HTTPS in ASP.NET Core in Docker Linux Containers Deep Dive

ASP.NET Core lights up HTTPS by default. Running from the command line or from Visual Studio installs and trusts self-signed certificates so we don't get the browser error when debugging. But how do we get this trust experience when running inside Linux Docker containers? Let's dive deep into certificate trust, how Linux stores certificates, and how ASP.NET Core uses certificates. With that knowledge in place, let's build up Docker containers for both development (self-signed) work, and containers that have real, trusted certificates should you choose a Layer-4 load balancer in production.

Git Scenarios: How Do I Fix That?

Have you ever wondered how to get out of a bad merge? Have you ever gotten stuck trying to push your changes? Git is a wonderful and empowering tool, but it's not your father's version control system. Bring your Git questions for this no-slides demo of Git command line and GUI tools. We'll harvest your curiosities, add in some common concerns, and run through these scenarios together. Have an open-source project you're stuck on? Bring the GitHub URL, and not only will we discuss it, I'll submit a pull request with the changes we build.

Git 101 and GitHub 102

Git is now the defacto-standard version control system. We almost take for granted that we all know Git. But Git is different from your father's version control system. Have you always wondered how it worked? What's the difference between Git and GitHub? How do I get involved in open-source? And what's a Pull Request anyway? Come join us for this hands-on look at Git and GitHub.

Gaining Confidence with Cypress Tests

Have you ever wanted to refactor mercilessly but didn't want to break the fragile tower? Or have you ever pushed to production only to spend the next few days cleaning up the regressions? You need integration tests, and Cypress is a great, fast way to build them. With a simple JavaScript or TypeScript interface, you can automate browsers to hit those critical functions in your app to prove it works as expected -- this time and every time. Join us to dive into building Cypress tests and leave with confidence to refactor your way to greatness.

Docker for the Windows Developer

Docker is carefully tucked between virtualization, continuous deployment, and pure awesome. We'll look at the commands and ecosystem around building infrastructure as code, deploying a swarm, and sharing images on Docker Hub. We'll see how easy it is to create Linux and Windows docker images, and run both single containers and a whole system. Come see why devs and ops love Docker.

Databases in the Microservices World

Web technologies have come leaps and bounds. But are you still using the tired old database from last generation? Let's look at the methodology of microservices, compare it to bounded contexts, and look at ops tasks for micro-databases. Let's tour all the flavors of databases, understand their pros and cons, and when you would choose it. You'll leave with a roadmap for moving from data-monolith to micro-databases.

Why do we refactor apps into microservices but end up with a monolith database? We look at how to handle the monolithic database (bounded contexts), what we need to get to micro-databases (automation), and now that we have lots of databases, we explore the types of databases and when you'd use them: SQL, NoSQL, time-series, graph, object store (file system), etc.

Database DevOps with Containers

Unlike CI/CD pipelines for applications, we can't just delete the database and pop up a new one with each new version. Let's start with the production database, and get SQL Server content to developers in containers, and then flow schema and lookup data back into production with migration tools. You can bring the reliability and automation of CI/CD pipelines to Database DevOps with containers.

Data Warehouse, Data Lake, Data Mesh, Oh My: The History of Data Storage

Are you looking to modernize your data infrastructure? Or are you confused at what all the terms mean? Let's look at the history of data storage from the humble beginnings of the relational database through the modern cloud-native data mesh paradigm. Data storage has evolved, and you can too.

Containerized Deployments for your SPA and API

You've built a SPA and an API backend, and you're now looking to deploy with ease. Docker is the natural fit, but where do we begin? We'll use the Vue CLI and the dotnet CLI to startup our codebases, then craft Dockerfiles to deploy these with ease in various configurations. Whether you'd rather deploy both parts together or scale different pieces separately, Docker can empower you to deploy your solutions at cloud scale.

Container Scanning: Run Fast and Stay Safe

Have you struggled to get security baked into your DevOps process or have your security needs taken a back seat to "run fast and break things"? Just because we’re moving fast doesn't mean we can’t be secure. Join us for this deep dive into adding container scanning to a DevOps pipeline. We'll enumerate the security tool categories, and give you tips for adding these tools to your development workflow, build pipeline, and production monitoring setup. You can achieve a robust security posture and still release continuously.

Choosing from the many ways to Docker in Azure

You're ready to go cloud native with containers. Now where do you begin on Azure? There's a dizying amount of container options available in Azure. How do they compare? Which is best for your organization? Come with us through a tour of each Azure Container hosting technology, the pros and cons of each, and decide for yourself how best to host your containers on Azure.

Building Stateful Workloads in Kubernetes

It's day 2. Kubernetes is running. You have your deployments and services set. Now how do you migrate the data store? Let's journey together on this code-focused tour through ConfigMaps, Secrets, Persistent Volumes, Persistent Volume Claims, and StatefulSets. We'll craft and launch a strategy to care for your users' data in this new container world. You can power your business on Kubernetes: stateless or stateful.

Build Components in Context with Storybook

Have you ever wanted to document how it works to others? Or wanted to understand all the states of your component without having to push next a dozen times in the app between refreshes? Storybook provides a canvas for developing and documenting web components in all their states. It's a great harness for experiencing your components how consumers will. Join us for this journey into building a component with Storybook as our guide.

At The Helm of Kubernetes: Repeatable Infrastructure Creation for Mere Mortals

As we get deeper into Kubernetes yaml files, we see a lot of duplication. Can we move to a higher level that eliminates this duplication? Let's look at Helm, a tool both for templating k8s yaml files and for installing complex infrastructure dependencies as one package. With Helm 3, we now have deeper integration and more security when working with Kubernetes. Join us on this path to a simpler, more repeatable, and more discoverable yaml experience.

ASP.NET in Linux and Windows containers

Docker is carefully tucked between virtualization, continuous deployment, and pure awesome. ASP.NET Core is a cross-platform, open-source reimagination of the Microsoft stack. They come together in beautiful synchrony. Whether you're targeting Linux or Windows workloads, you can build your ASP.NET app into containers, and still have the F5 debugging experience you expect.

ASP.NET Core in Containers on .NET 6

Docker is carefully tucked between virtualization, continuous deployment, and pure awesome. ASP.NET Core is a cross-platform, open-source reimagination of the Microsoft stack. They come together in beautiful synchrony. Whether you're targeting Linux or Windows workloads, you can build your ASP.NET app into containers, and still have the F5 debugging experience you expect.

Anatomy of a Web Request

What happens after you type the web address before the page renders? Is it a black box to you? It doesn't need to be. We'll peel back the onion and look at DNS, HTTP, TLS, and briefly discuss the client render pipeline and windows metaphors. Ultimately we'll see the internet is not a black box. Open the lid and look inside.

A Database DevOps Pipeline

Are your automation practices accounting for the database? How do you verify database software quality? Most importantly, how do you care for customer data as the schema evolves? Let's dig into building a CI/CD pipeline for databases. We'll leverage Red Gate tools and containers for automation, testing, and push-button deployment. You can bring DevOps to the database.

[Workshop] Kubernetes hands-on

Kubernetes is how you run Docker in production. Bring your laptop with Docker for Windows or Docker for Mac edge version installed. We'll walk through getting a K8s cluster fired up on Docker-Desktop, minikube, and on Azure. You'll be hosting Docker containers in development and production in no time. We'll dig deep into:

- A quick tour through Docker concepts
- The components of a kubernetes cluster
- pods, services, deployments, and replicas
- ways to scale and expose/isolate your containers
- public and private container registries
- stateful containers
- promoting from development to production
- Azure Container Service (AKS)
- Best practices for building at cloud scale
- Tips & Tricks for leveraging Docker and Kubernetes
- When not to use Kubernetes

We'll look at the commands and ecosystem around building infrastructure as code, local and cloud clusters, and best practices with containers. Come see why devs and ops love Kubernetes.

Level-up Your DevOps with GitHub Actions and Kubernetes

Are you looking to rapidly deploy your content? Are Docker containers in your future? Come for this demo-only presentation where we start from scratch, live-code a Dockerfile, build up a DevOps pipeline in GitHub Actions, and deploy to Kubernetes. Once setup, commit, and watch the magic flow into place. You too can automate your deployments.