With the introduction of the new Hybrid .NET MAUI Blazor model developers are provided an entirely different method of interacting/building .NET applications that target iOS and Android. This session takes a dive into this technology and talks about the practicality of what this technology means, how it might be used and next steps.

We will explore the following * Project structure overview * End-user differences between using a traditional MAUI implementation vs MAUI Blazor * Performance & Security considerations * Store submission guidance

At the end of this session attendees will see a real-world example of an appliation built with .NET MAUI Blazor and will be able to reference the solution after the event to help in their own technology research.

The Microsoft Dynamics365 platform is an extremely powerful platform that can be leveraged to manage many aspects of a business. Whether it comes to sales, marketing, service management, finance, or a number of other custom solution offerings many businesses can benefit from the Dynamics 365 platform.

Many architects and developers are unfamiliar with this platform and how it can be leveraged to provide a powerful and easily customized solution.

During this session we will demonstrate and discuss the following topics:

• An overview of Dynamics, it’s pricing, and how it can be leveraged in various scenarios • Extending the Dynamics data structures through Dataverse • Customizing the Dynamics 365 UI Model-driven Power Apps • External integrations with Dynamics 365 via APIs (demonstrated in C#) • Reporting on Dynamics data through PowerBI • The general development workflow for customizing Dynamics environments

This session will be a great way to familiarize your team with the Dynamics eco-system and the possibilities which exist for building on top of it’s foundation to quickly and efficiently provide powerful business solutions.

Agile is all around us. We see agile in small and large software teams. We see groups holding standups, using Kanban boards, and conducting retrospectives. IT and business teams are asked to do more with less and get it done quicker…and agile is the answer to all of that. Is it really the silver bullet? Will we get to our goals if we adopt agile practices? Do we know if we're doing things in a way that will help us?

An agile implementation based on incomplete or erroneous information may be creating as many issues as it solves. We may be doing twice the work to "transform" to agile without seeing any tangible benefits. In the end, we fail in our goals and we're ready to go back to what we know best.

But what if it isn't that hard? What if we just need a bit of core knowledge, a chance to practice, and a safe environment where we can ask the questions that will move the needle?

The team leading this workshop organizes Lincoln's agileLNK Meetup group (https://www.meetup.com/agileLNK/). At this workshop, we will demonstrate several agile techniques, explain when to use them (and when not to), and discuss the foundational agile principals behind each one. Every team uses standup meetings, right? What if not everyone is in the same time zone…or hemisphere? You will learn how to use familiar agile activities, but also why to use them and what alternatives fit better in different situations.

Common agile topics we will cover during the session: * Sprints/iterations * Standups * Backlogs * Retrospectives * Metrics * Self-organizing teams * Kanban * Scrum

We will have plenty of informal interaction time as well. Have a tough question or need advice? No problem. We're here to help!

We’re all familiar with the notion that software is everywhere, and that in some way it touches nearly every product you’ll ever own. One such product is dimensional lumber, like a 2x4 or 4x4. There are a number of steps between a tree in a forest and a piece of lumber you buy in a store. One of those is ‘edging’, the process of removing the living edge from a flat section of raw material, and producing a board of an appropriate width with straight sides.

This talk is a post-mortem of a prototype system we built for optimizing the potential value of material coming out of an edger. While the AI for optimizing produced material was an important part of our system, it wasn’t the only part of our system!

In this talk, we’ll cover: * The general problem of dimensional lumber extraction * How the client’s brand influenced which AI techniques we used to solve the problem * How AI is just a part of a larger software product, including * How we took an agile approach to AI development * How we handled estimating the cost of building the solver (and the rest of the software) * How AI integrated with the rest of the team

I’m hoping the audience takes away: * Sometimes the best technical solution is not the best overall solution * Even when AI is required for a product, it is never the whole product * AI software isn’t ‘special’ from a best-development-practices perspective

Commercial real estate is responsible for 30% of the world's carbon emissions. There’s 40 billion sqft of unused commercial real estate. A combination of bouncing lasers (and radar) off of people and machine learning on customer hardware is being used to solve this problem - ensuring that realestate is being properly utilized. We take it a step farther, and maintain anonymity while we're at it.

This talk is a deep dive into how Density processes 250,000 sensor readings every second (counting 1 million people daily) to inform actionable insights for Fortune 5000 companies.

Architecting an application can be challenging. What do you do to keep your application flexible to ever-constant requirement changes? How do you handle landscape changes (cloud, on-premises, databases)? How do you avoid over-engineering the application? How do I make sure my application plays well with other applications?

In this session, we’ll take a look at some well-understood and practiced Software Architecture patterns. We’ll cover these patterns at a high level to understand how to use these patterns in different scenarios.

You’ll walk away with some knowledge, tips, and tricks that you’ll be able to use for new and existing applications.

A well-architected system is foundational for organizations needing to meet their business goals. How development teams approach building and maintaining these systems makes all the difference.

Software architecture and systems engineering are complex topics. No StackOverflow post will tell you everything you need to know.

This talk will break down some of the key concepts you must understand to become a successful software architect. We will talk about decomposing systems into modules, orchestration, logical vs. physical architecture, and managing all the critical - ilities (scalability, extensibility, stability, and so on). Looking at some existing industry ideas like volatility-based or DDD (domain-driven design) will help clarify these abstract ideas.

Concepts covered here will benefit both existing and aspiring architects.

Microsoft Excel is used extensively in business. The Python programming language is a popular language that is easy-to-read and quick to learn.

You can use Python to read and write Excel documents without even having Excel installed. In this talk, you will learn how to do the following:

• Read Excel spreadsheets
• Create Excel spreadsheets
• Edit existing Excel spreadsheets
• Style text in cells
• Automate the creation of charts in Excel
• and more!

How quickly does your application respond to security threats?

Most applications rely on security logs (assuming they are present) sent to a monitoring repository, where they are correllated against other activity, analyzed for risk, and responded to when the monitoring team has time.

At that point, an attacker may already have breached the application, or gotten enough information to come back later. Instead, what if we allowed the application to block malicious activity automatically before it had time to become an issue?

In this session, I will present several strategies for developing traps and pitfalls within an application that can catch hacker behavior, and even block the offending user, before any damage is done.

Artificial Intelligence (AI) is no longer science fiction; it’s here today, and it’s here to stay. It is in the products you use every day: home automation, digital assistants, or credit card fraud detection, just to name a few. All businesses will be affected by AI in the coming years, and the impact will be significant. The only remaining question is, how will you influence its effect on your company?

Getting started with AI is a daunting task, but necessary for businesses who want to stay competitive. During this session, we’ll discuss: * How to determine if, where, and how to use AI effectively within your organization * When and how to build an AI team * Common early mistakes and pitfalls when getting started with AI * Typical misconceptions around AI and its application * What to look for in an AI partner or potential hire

Have you ever found yourself reviewing a huge merge request from a task or feature branch? Trying to do a complete and thorough job of reviewing the code? Did you miss things? Did you hate your job? Did you think there has to be a better way?

If this describes you then join us as we discuss the benefits of a trunk-based development model!

In this presentation we’ll be discussing: * Common issues with branching based development processes * How Trunk based development can help solve these issues * Pitfalls to watchout for in Trunk based development * Best practices and helpful tools in switching to trunk based development

Weclome to Blazor and application security. Take it to the next level by using Microsoft's Identity scaffolding to add role based security to your application. Blazor and entity framework are a natural fit for user authentication and role based access to your application. This session takes the mystery out of all those questions you've always had and show cases the solution in terms that are easy to understand and replicate.

At this conclusion of this session you will know how to add a login/logout section to your site also how to lock down features by user role.

Code Reviews can sometime be painful and time-consuming, but they are an important part of delivering quality software. A Code Review provides an opportunity to share knowledge, improve code and catch potential problems before they go to production. This can be a positive experience or a negative experience. In this session, I will discuss the importance of Code Reviews and show some ways you can make your code reviews more productive, enjoyable, and successful.

At this point a lot of companies are comfortable and familiar with the concept of dogfooding, the practice of using your software as a method of functional testing. But what happens if we want to practice securing our applications against attackers or people who would seek to misuse it? Enter ‘Blowing up the Dog Food’ or a fun way to include members of the development and QA team to get involved to test the security of the application. The goal is to setup a method for helping teams to think critically about the implementation of their applications, improve logging to catch misuse, practice the implementations of threat modeling, and test out the security of an application in a way that helps to develop orange team skills in developers as well as test the applications.

In this breakout session you will develop a Blazor CRUD application. We will cover everything from dependency injection, the C# JS Interop, entity framework and so much more. Use your C# knowledge to hydrate information directly to your web pages and see how components interact naturally within the Blazor environment. This course assumes you have knowledge of C# and an interest in Blazor and/or Web Assembly. You will leave this course with a working CRUD application and a solid foundation of how to build Blazor applications.

In this presentation, I will talk about what Serverless is and what some of the different Serverless technologies are that Azure offers.

After this introduction, I will discuss more about how to architect a system to be event driven and embrace the use of Azure Serverless frameworks.

Finally, a demo of using some of these frameworks will be shown and a discussion of how developers can start using these frameworks today.

Testing is vital to any software project. Automated tests help improve confidence in code changes as you increase project velocity. Finding the right tools and libraries can be an arduous process. And, in most languages, adding testing means adding a pile of new dependencies to the project. But, have you ever tried the tools built right into the language? One of the beauty's of the Go programming language is that it is built with productivity in mind. The creators of the language have included many tools that make developers productive--including a robost testing framework. Come see how easy it is to get started with Go's testing library and see many of the features that will keep you using it in all your projects.

Everyone has heard the old adage "measure twice, cut once" yet it can be so difficult to get a team to adopt this mentality when it comes to writing code (cough cough... unit tests...). Software may not be quite as tangible as a bridge or an airplane, therefore it can be easy to dismiss the fields of structural/mechanical and software engineering as having little to nothing in common. However, many of the foundations of Agile stem from the manufacturing industry, and the co-creator of Scrum Jeff Sutherland writes of how applying Scrum to a construction project can greatly reduce the overall project time and improve quality. In reality, all of these fields are about buidling, maintaining and improving things and thus they have a lot more in common than you would expect.

During this presentation I'll share some of the lessons that I learned growing up building houses, and high-performance race cars with a father who is a bit of a perfectionist and we'll explore how many of those lessons can help improve how we approach software development. We'll also briefly discuss why some other industries could gain a lot from adopting some common software practices.

In this talk, Alain is going to introduce a simple method to make our presentation components not so dumb anymore. Using content projection, we will see how we can build components that can be used in multiple different contexts, offer a lot of customization options, and have an easy to understand API.

Description

Whether you are a product owner, manager, analyst, engineer, or tester, you build products. And building products is challenging - not only getting the product right but also making sure the team working on the product understands the nuances of your product. How do you go about designing, delivering, and adapting your product to deliver better solutions while incorporating product learnings as you go?

In this 1-day hands-on workshop, you will learn and use product discovery tools used to help teams discover and continuously learn about their product. You will learn:

Lean Product Discovery with product framing, design targets, and storymapping
Product validation with experience tests
Driving product language within and across teams
Blending discovery with delivery to drive continuous product learning

You will use:

Product framing, design targets, and OKRs to drive product alignment and meaning
Storymapping and user journeys to explore options, dependencies, and validate decisions
Annotations to drive product language within and across teams
Leveraging continual product discovery as part of product development

All exercises are hands on and done in small groups Who should attend:

Product Owners / Managers looking to understand how to blend product thinking into delivery within and across teams
Managers, analysts, designers, and team leads challenged with getting the 'requirements' right
Engineers tired of not having a voice in the process

Whether you are new to product discovery and lean or are looking to hone your skills, this class will give you hands on experience applying these techniques in real world scenarios. The course is designed for anyone working on building or leading teams building products, within or outside of software.

It's cheap to get started in the cloud and start sandboxing. Soon after, there's a production environment and more infrastructure is being stood up in the cloud. Then the bill comes and it seems cloud costs are uncontrollable.

This presentation is designed to provide high level strategies and concepts to control cloud costs. We will also go over how DevOps automation plays a big role in how you can control your cloud costs. No matter which cloud provider you use, this presentation will help you have a path forward on starting cost control measures.

Are you interested in how some of the leading gamblers are using machine learning? Are you interested in deep learning and want to see it applied? Are you interested to see how certain stats line up with actual results? If so, this talk is for you.

The talk will start with an overview of data collection, it will then go into how I used Google Colab to train and test my models, finally, it will show how to deploy the model to the masses through an Android application or a web site.

Debugging issues within applications are challenging! In this session, I’ll how debugging works and demonstrate the many ways that Visual Studio enables you to find those annoying issues. I’ll explain the run/debug configurations. What application breakpoints are and to make them conditional, or how you can skip breakpoints altogether. While we are in a breakpoint, we’ll explore the many ways to navigate through the code but skipping lines, running to line, jumping in, and using methods. Once we find an issue, we’ll look at how we can inspect the values in memory and even change them.

At the end of the session, you’ll walk away with a lot of knowledge to help you find those annoying issues in your applications. As a bonus, you’ll walk away with a little debugging secret.

The in’s and out’s of understanding the complexities of Azure pricing can get a bit complicated. During this talk presenters Alex Will and Kevin Grossnicklaus will discuss strategies around planning for and paying for Azure consumption and other Microsoft services such as Office 365 and Dynamics 365. As a Microsoft Cloud Solution Provider we set up and manage Azure and Microsoft 365 environments for customers all over the US. In doing so we’ve tried many different approaches to creating and updating environments to better utilize the dollars spent by our customers while providing robust cloud solutions. We’re sharing the best practices we’ve learned and adopted to create the ideal end result: predictable pricing with the best experience possible. This includes not only making smart initial decisions on configuring new environments but also in managing and reporting on ongoing costs to make better use of the resources you are ultimately paying for.

Some high level topics we will cover include:

Basic overview of how Azure and other Microsoft services are priced and how billing is generally accomplished

Tips and tricks on estimating and implementing Azure applications with regards to pricing

Reserved pricing vs consumption based pricing

Discussion of pricing around specific resource and service types

Managing your billing and tracking towards a monthly budget

Cost savings options and other advanced topics

As time allows we will gladly answer and many questions as we can from attendees.

As one of the most important principles of DevOps, treating configuration and infrastructure as code is critical to the success of high performing organizations. Without accelerating the ability of teams to manage systems the same way developers manage application code, infrastructure becomes a bottleneck preventing stable, agile, and high performing systems from becoming a reality. This session will review what different solutions for configuration management and infrastructure as code are available to teams entering this space. Learn how to use these platforms together to maximize your ability to churn out systems and services as quickly as committing code to source control. We will introduce the basics of solutions like Puppet, Chef, Ansible, and Terraform to provide a rubric for demystifying your path to quickly provisioning cloud infrastructure.

During this all day workshop we will demonstrate how to plan for and manage the full lifecycle of a modern application using the latest Microsoft Azure resources and tooling. We will start with a high level overview of a wide variety of architectural and Cloud-based considerations and we will then work our way down through a complete setup of a basic application all the way from a clean Azure DevOps and GIT repo setup, through bootstrapping an empty UI in Angular and a robust API using .NET Core/C#. We will demonstrate how to fully automate the deployment and development lifecycle of these application components up to Azure. We will ultimately take the same Azure configuration and convert it to a full “infrastructure as code” setup using Terraform.

We will also discuss how to efficiently and cost-effectively make use of Azure resources by demonstrating various best practices for choosing the right components and proactively monitoring utilization and costs of your applications.

If you want an example of a very robust and “real world” Cloud-based architecture targeted to Microsoft Azure then this 8 hour workshop will be something you do not want to miss.

Agenda:

Architectures in Azure Framework choices from .NET Core to NodeJS to Mobile GIT Best Practices for Branching and Versioning Database Options and Implications Azure DevOps Pipelines Azure Planning and Pricing Containerization Ongoing Monitoring and Support

This talk is designed to quickly introduce developers to a wide range of useful tools and services we have found extremely useful in helping us provide better solutions, improving our development process, and generally just making our lives easier.  

These tools range from sites that provide useful services for developers, APIs we frequently utilize within our applications to provide more capabilities, SDKs and libraries we commonly leverage, and utilities we find useful.  

Our goal with this talk is to quickly demonstrate a large number of useful tools, utilities, and APIs and leave attendees with the resources they need to find out more.   Some of these tools are free/open source and others are commercial, but we find them all extremely useful and can’t wait to share how we use them.

We will discuss:

Developer utilities (all the way down to our favorite command prompts) 3rd party APIs Productivity software IDEs and plugins Useful NPM and NuGet packages

We spend much of our time collecting and analyzing data. That data is only useful if it can be displayed in a meaningful, understandable way. Yale professor Edward Tufte presented many ideas on how to effectively present data to an audience or end user. In this session, I will explain some of Tufte's most important guidelines about data visualization and how you can apply those guidelines to your own data. You will learn what to include, what to remove, and what to avoid in your charts, graphs, maps and other images that represent data.

During this full day workshop you will dive deep into the world of atmospheric science using some really cool Python libraries. We'll start by setting up a containerized development environment in Docker with JupyterLab so we can explore different weather datasets, including both deterministic and ensemble model forecasts, RADAR, and satelite imagery. Afterwards, we'll look at using Numpy, SciPy and Pandas to apply algorithms to the data to create derived products. We'll measure the performance across different tools to see how much speed can be gained through these libraries without having to switch to a fully compiled language. Next we'll look at how to use Airflow for automating the generation of these products upon data avaialability. Finally, we'll tie it altogether by building a sample FastAPI to expose a handful of your custom products via an OpenAPI compliant end point to populate your own website!

You'll want a Windows/Mac/Linux laptop capable of running Docker. Pre-installation of Docker and VSCode will be enough to get you started as we will provide dev containers with all of the dependencies set up for you.

Attendees will understand the benefits of creating their own extended version of the Amazon Cloud Development Kit. They will see how defining rules and setting up standards around CDK can enable better, safer and more maintainable infrastructure as code.

In this session we will very briefly review the User Centered Design process so no prior knowledge is needed and we will dig deeper into personas and paper prototyping. For the second half of the session you will have the opportunity to try a simple paper prototyping project.

This session will be more hands on.

Google makes it harder and harder to pass Core Web Vitals with vanilla content management systems (CMS). What if we could combine the world of custom development while still having a CMS that non-developers could use to add content? What if your WordPress site could be developed and maintained through normal software development practices using continuous integration? Wouldn't this make a great future? What if I told you the future is here!?!? This session will walk you through the multiple recipes and processes of building a site that utilizes a content management system, including WordPress to build sites that are fast, secure, and scalable. You will learn about some tools that you can utilize and learn from some of our mistakes in building these sites. The session will end with a demo of utilizing some of these tools.

With modern tools, building a cross-platform app has never been easier. In this session, we'll take a look at how to get started with Expo to develop react-native apps that work on IOS, Android, and even the web - all with the same code! Combine this with a hosted API service and you can get your next side-project or startup MVP off the ground in record time. We'll cover project structure, component libraries, and other utilities to help you get started quickly.

Experience with React development will be assumed for this session.

Most uses for CSS deal with formatting your document, positioning items, and changing items on mouse over. In this session, we will look at some fun things you can do with CSS and animate to make some cool effects. If you are new to CSS, this may be a good look at some other ways of using CSS to have some fun and add a little spice to your site.

Kubernetes, also known as K8s, is an open-source system for automating deployment, scaling, and management of containerized applications. In this session, Vaibhav will cover the basics of Kubernetes including the different components that make up a Kubernetes cluster, and how to get started with running Kubernetes locally.

How do you grow a continuously learning organization? If certifications and wikis were enough, organizations would be crushing it. In this session we look at how we learn in complex domains - focusing on tacit vs explicit knowledge; context learning; and growing coaches and teachers.

This session is an evolution of our talks around growing Dojos (though awareness of dojos is not necessary for this talk).

In this session we will look at the challenges facing organizations and people today trying to learn new skills (committment, context, multitude of needs).

From there we will look at how we learn exploring explicit vs tacit knowledge.

We will wrap up with tangible ways you can start growing an organization that continuous learns - looking at addressing the whole value stream to provide context and growing an organization that has internal coaches and teachers (along with models for that).

Our upcoming book (late summer 2022) will be based on coaching for learning.

2020 hit like a brick. 2021 did its best to up the ante, and then 2022 asked 2021 to hold its beer. It might feel like the entire world has been upended: there’s been radical shifts in the way we work, endless video conference calls, social and political unrest, lots of tough choices about our health and the health of those we love and care about, and now a brutal war in Europe. In short, it’s been several years of psychological trauma, and no clear sign of when it will finally be over. It might feel like there’s nothing you can do but hold on for dear life.

But there are things you can do. Let’s understand what’s been happening to your brain during this time: why your brain works the way it does, how it handles traumatic events like this, how to recover as things slowly start to get better, and how you can prepare yourself for the inevitable next crisis that comes along.

Your work is going swell and everyone seems to be happy. But are things going as well as they could be? What frustrations are people experiencing but not verbalizing? Does anyone think that things should be better?

Maybe your backlog keeps slowly growing or it's a struggle to meet sprint commitments. Is your team taking longer to onboard new team members? Are there quality issues in deliverables? Team turnover increasing? Maybe you just feel like things aren't as simple as they used to be. Perhaps it's time to look at your team structure and how you organize around the work you deliver.

Join me for a peek at what might be a canary-in-the-mine signal that it's time to consider splitting the team and how to work through the decision. We'll look at the risks/rewards you'll likely face. We'll explore some potential dimensions to consider when undertaking a split. I'll give you some things to consider preparing for the breakup, how to minimize the downsides and how to navigate through the process.

In this session we will take a look at how AutoFixture can simplify the arranging and asserting portions of your .NET unit tests. We'll explore how it integrates with mocking libraries to allow you to easily write tests and have dependency types automatically mocked and injected into your object under test. We'll also look at how AutoFixture can be extended and customized to make you more productive with your domain specific types. Why build your own mocks or create custom fakes when AutoFixture can do it for you?

We all know that Application Security is one of those things that we should worry about. The time to worry about it is not at 3am when the production server is down. But finding the right places to get started and getting success, or something that feels like success can be absolutely excruciating. Which is one of the reasons that it falls just above documentation in the list of priorities for most development teams. In this session we will talk about the ways that we can GREATLY improve the security of our applications, while playing games, making small changes, and light process changes.

In the tech world, we sit – a lot – as our jobs require us to occupy our chairs for hours on end. The number of people who complain of neck and back pain is on the rise, because our body is not evolved for sitting behind a desk and staring at screens. New studies say that sitting is the new smoking, so are we all doomed?

During this session, I will talk about “programmer back” and "tech neck" and show you a few poses that almost anyone can do to help undo the damage created by long days spent sitting at a desk.

Infrastructure as Code comes in many flavors, and the Azure Cloud's default deployment templates work with Azure Resource Manager (ARM) to define and deploy infrastructure. Working with the JSON format of ARM can be challenging, but Microsoft has introduced a language processor called Bicep which generates ARM as output. At the same time there are other options, including scripting tools, Terraform, Pulumi, Ansible and others. In this session we'll compare creating infrastructure using ARM, Bicep, Terraform and Pulumi, and compare pros and cons to each.

Deep Learning is a subset of Machine Learning where large and architecturally complex neural networks have been created for specific applications. This presentation will cover neural networks and three types of deep learning networks that are commonly used, in a less technical and more abstract way.

After the presentation, you should feel comfortable discussing the basics of neural networks and be aware that changing the architecture of a neural network can increase it's efficacy. Networks discussed: Convolutional neural networks, Recurrent neural networks, reinforcement learning

In this session we'll look into the platform services at Azure for IoT development and telemetry ingestion, including IoT Hub, Device Provisioning Service, Stream Analytics, and Storage. Using C#.Net, we'll set up a simulator and register some devices to send telemetry into our hub and process the stream data into hot and cold paths. We'll then finish up by discussing IoT Edge and development for IoT Edge

Have you ever done a google search and wondered why certain results showed up? I'm going to discuss how search engines work, how they analyze websites, and how they return the results to you. You can then use this information and apply it to your own strategy when building websites!

So your organization has been doing Scrum for a while and the powers that be decide it’s time to scale up that there agile. Or maybe more traditional frameworks just aren't delivering the right value at the right time and leadership is looking for a different way. So your boss introduces you to the SAFe consultant they’ve hired and a miraculous new level of scaled agile delivery is coming soon to a theater near you! We’re going to identify dependencies and deliver features and commit to multiple sprints. It’ll be glorious! That’s the promise. And in too many cases, the agility gets taken right out of the equation.

I have been a PMP project manager for 20+ years, an agilist for the last 10 years and I’ve both lived through SAFe implementations and observed them from a distance. A commonality I see is a reversion to siloed, waterfall thinking. This brearkout session is a discussion of those paralells and what we might be able to do as organizations/scrum masters/teams to nudge SAFe back toward agility.

Since C# was rewritten entirely from scatch for version 6, the updates to the C# language have been coming very quickly, both in major version release which typically correspond to a Visual Studio release, and out-of-band point releases that get new, useful features in developers' hands sooner rather than later. With all the changes happening, it's difficult to keep up, and that means you may be missing out on some language features that will make you a more productive programmer. In this session, I'll take you through some of the best C# language features that have been introduced recently and prepare you to use them to their full potential.

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.

Lean Coffee is a structured, but agenda-less meeting. Participants gather, build an agenda, and begin talking. Conversations are directed and productive because the agenda for the meeting was democratically generated.

Until now, end-to-end testing wasn’t easy. It was the part developers hated. Cypress is a solution that makes setting up, writing, running and debugging end-to-end tests easy.

In this workshop, we're going to demonstrate how Cypress works, take a look at its features, and write a lot of tests so we get as much hands-on practice time as possible.

Problem-solving is an important skill in our industry, but it tends to be a talent that is overlooked and underdeveloped. Some of us may even think of it as a natural talent: something that you either have or don't have. However, this is simply not true. You can learn effective strategies for problem solving in the same way you can learn to play an instrument. You only need to know what to look for, and practice it just as you would any other skill. In this session, you will learn valuable techniques and strategies for problem-solving, and how to apply these tools to finding technical solutions for your business needs.

1982 was a turning point in the Cold War when a Sovient gas pipeline exploded and caused billions in damage to their infrastructure. How did the CIA use software to pull it off? What can we learn from these events? What questions of ethics arise from the CIA's involvement? We will discuss these questions and more.

You've decided Machine Learning (ML) can help your customers? Great! But ML can be difficult, time consuming, and expensive. Agile practices can reduce these costs and improve outcomes in the same way they've always helped: by making sure we're building the right thing every step of the way.

We've identified, and our presentation will speak to, the following anti-patterns for machine learning and agile approaches that avoid these anti-patterns. We value: * Iterative over incremental * Always be releasable over "toss it over the wall" at the end * ML as a means over ML as the end goal

For each anti-pattern, we will present several techniques to mitigate it.

Avoiding Incremental Development In Favor Of Iteration * Find 'minimal learnable concept' and get a complete ML pipeline quickly * Improve your ML pipeline from data preparation to deployment, don't waterfall it * Realize when something isn't feasible early on to avoid wasted effort

Integrate ML In The Product From The Start, Not At The End * Avoid answering the wrong question by focusing on outcomes and stories * Prevent overwork by only doing what's needed to get the desired result * Experts may identify easier-to-solve adjacent problems that have comparable outcomes for users

ML is a feature like any other - it is a means, not an end * Identify when it is not the right tool for the job * Know when good enough is good enough * ML stories should be prioritized, have story points, etc.

With Event Hub, IoT Hub, Service Bus, and Azure Storage Queue, Azure has a number of PaaS offerings available when it comes to Queueing, Eventing, and Messaging. The number of services and mystery about their purposes can lead to a bit of analysis paralysis when it comes to which service to use, and, more importantly, when to use each service.

In this session we will explore the services available at Azure for queueing, handling events, and messaging, and we'll look at appropriate examples of when and how to use each of them. By the end of the talk you'll be ready to go make a recommendation to your team about which service to use for various scenarios, and you'll have seen how to easily integrate these services into your .Net applications.

Metrics are a good thing when we ground them in decisions we want to make. Metrics for the sake of having metrics loses its purpose.

In this session, we will walk through a simple way of grouping metrics - from easy to collect, to directional, to impactful. Along the way, we will give examples of metrics in each group - what they mean, why they are good, where they fall apart. All along working towards better metrics and the approach to collecting and using them.

Additionally we will introduce and show process behaviour charts - a technique that looks at data and helps separate noise from signal.

Leave this session with simple ways to group metrics and ways to interpret if your changes (product, process, or people) are making a difference.

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.

When developing front-end applications with TypeScript, a common pain point is synchronizing your API data types with your UI. In this session, we'll look at a number of tools and techniques for taming this complexity. Whether you need a REST API or a GraphQL API, you'll learn how to leverage a combination of types and code generation to modernize your development experience from the server to the client.

Infrastructure as Code (IaC) is a way to describe architecture components textually using executable software code that is managed in version control. Being executable means it can be fed through an execution engine to generate infrastructure in a consistent and repeatable manner. Being written in human consumable form and stored in a version control system just like any other piece of software enables teams to collaborate on the evolution of their architecture's infrastructure reviewing and approving changes alleviating the knowledge silos of traditional provisioning methods.

Several implementations of IaC have been introduced such as Terraform, Ansible, CloudFormation, and Chef and most have grown to significant popularity due to their ability to capture the benefits described earlier. A consistent challenge of the previously mentioned IaC technologies is the need to learn a domain specific language which to various extents are generally restrictive to declarative configuration style syntax. However, there has been an emergent technology called Cloud Development Kit (CDK) offered by Amazon Web Services (AWS) which has shown significant promise extending the benefits of IaC.

AWS CDK empowers developers to use one of several familiar programming languages like Typescript, Python, Java, and C# along with powerful Object-Oriented Programming paradigms and patterns. Together the use of these familiar high-level programming languages and patterns allow for composing reusable and extendable constructs that produce enterprise level cloud architecture with surprisingly small amounts of well-crafted CDK IaC code utilizing opinionated defaults ensuring security and consistent provisioning.

In this talk we’ll explore the key concepts of AWS CDK focusing on the abstractions and patterns it utilizes to go beyond the standard benefits of IaC to provide a highly productive framework for provisioning robust and scalable cloud architectures.

Attendees will learn how to shift from doing ad-hoc deployments of web applications to Azure App Service to doing fully Terraformed, CI/CD pipeline deployments to Azure Kubernetes Services. I'll to cover how this shift occurred for our organization and how we handled it with the developers and business.

The end-result of this move was to bring us from doing periodic night-time deployments to zero-downtime continuous deployments. I'll show how we were able to make this happen within a matter of just a few months.

Tools you'll learn about: * Docker * Terraform / Terragrunt * AKS * Azure DevOps Pipelines * Azure Container Registry

Are you intimidated by operating a screen reader? For most sighted individuals using a screen reader is something they've never done before. If you're a developer or a QA that is producing accessible products using a screen reader becomes something that we must use for our jobs. And frankly, learning how to use one is not a easy feat.

This talk will go over how screen readers interact with the web, the basics of getting a screen reader setup on your computer, and how to operate it. You'll leave this session greater knowledge of accessible development and how to use a screen reader effectively.

This session is designed to introduce developers how to effieciently query their document databases. We will also look at metrics that could be a bad query smell.

We will be using Mongo in this session for our document store. All of these principals still apply to other Document stores.

Application developers are the first line in defending applications from attack, there are thousands of software and hardware solutions to attempt to make your software more safe and secure. In the end if the software isn't developed properly and securly no amount of software or hardware is going to protect you. In this session I plan to go over, identifying weak code, testing for it, and fixing it.

In this session we will go over indepth the process for doing application security testing on your own applications. As part of the session we will go through and identify all of the items on the OWASP top 10, how to test them using DVWA (the Damn Vulerable Web Application), and talk about strategies to mitigate the.

Requirements: Students to the class must have:

• A laptop that they have root or administrator access to.
• A laptop capable of running a virtual box machine, multi-core, with 8gb+ of ram.

All materials outside of the Requirements will be provided.

Have you wondered how to advance in your career when you have multiple options? Or how to recruit the right team for your project or organization?

Searching for the optimum job or team member can be viewed as a mathematical optimization problem that we can navigate using well known heuristics.

Heuristic algorithms are techniques that can be used to solve decision problems that have no clear procedure, which in technical terms are called, NP-Complete problems. These innovative algorithms have been applied to engineering and financial problems for decades.

In this talk, you will learn how to use them in your own career planning or organization's recruitment strategy.

You will also learn how combinatorial optimization algorithms, such as simulated annealing and stochastic optimization can help professionals to get unstuck in their career advancement.

Organizations can also use the technique in recruitment and team building.

Your thoughts and your emotions affect your work, no matter how much you pretend that you can leave them at the door of your workplace. It’s easy to deny your own experience the importance it deserves, especially if it’s only inside your own head. But boxing it all away because you have “work to do” is like trying to run a marathon while carrying a labrador retriever.

It doesn’t have to be that way. This talk will teach you how to frame your world in experiential language rather than clinical language, giving you a powerful tool to discuss your mental health in a way that can be easily understood - and won’t get you in trouble with HR. Sharing those experiences are the key that unlocks the true power of your team.

Pair Programming is a highly recommended but seldom utilized agile development practice. Primarily originating and associated with Extreme Programming, Pair Programming is often misunderstood and therefore left by the way side when agile teams get going with development. I want to go back to the basics of pair programming and show why it should be a practice every team employs. In Design Studio and Senior Design, we managed nearly 40 projects with more than 200 student team members combined. Pair Programming can greatly impact these students’ careers in software development once they have realized its power and taken advantage of its benefits. Let’s bring it back down to the basics to remind you of this great opportunity.

An application is an idea that has code, data and infrastructure, and choosing whether to build a conveyor belt or to put up guard rails along the path is important in maintaining velocity to the cloud. In this session, updated for 2022, we explore the tools available in Azure for creating and enforcing governance policy, standards and infrastructure, including Azure resource template technologies, Terraform and Bicep, Azure blueprints, as well as DevOps processes including GitHub Actions that you can use to ensure your cloud journey is predictable, secure and compliant. We’ll see how the tools work and share best practices for maturing your cloud journey.

Event Sourcing has been growing in popularity for the last decade as an alternative to Create Read Update Delete (CRUD) to help wrangle complexity in challenging domains. Yet we occasionally hear stories of the inverse happening. Where complexity is increased, development speed and confidence drops, and deadlines are missed. Why is this? More often than not it's because fundamental principles and warning signs are ignored or are simply just not known to the team. This talk will briefly recap these paradigms and then dive into what ensures success for systems that strive for resiliency, traceability, idempotency, and tend to be data-intensive.

We all love those days when everything goes right and we just knock it out of the park. What makes some days great and others a real chore? For a lot of developers, the biggest factor to having a great day at work is a sense of accomplishment. So come explore how we can get the most from our hours and increase the number of awesome days. In this talk we will examine what motivates us, how to stay focused, and cover some powerful productivity tips and tricks. We will look at some tools and techniques that will help you be a more effective developer. Don't just refactor your code, refactor your life.

As infrastructure stacks grow increasingly more complex and involve an ever-growing number of services and systems there are a lot of opportunities for error and misconfiguration. To provide more system stability teams have looked to abstract configuration to its own layer of code. This concept of configuring infrastructure as code is gaining traction throughout the industry for a variety of reasons. It's fast, consistent, reduces errors, self-documentation, and did I mention it's fast? Tools such as Terraform from HashiCorp have emerged as one of the leading ways to declaratively configure technology stacks.

In this talk you'll gain an understanding of the benefits of Infrastructure as Code in general, and of using Terraform specifically. You'll be introduced to how Terraform works, what the code looks like, and how to get started.

Have you ever worked on a software project that felt like a death march? Where you had no hope of success and even if you did release it, you knew it wouldn’t last long. Have you ever been afraid to make code changes because you weren’t sure if you were going to make the problem worse? Are you unsure how you should structure your code and software components? If any of these questions bring back bad memories or remind you of your current projects, then this presentation is perfect for you.

We will walk through a few examples demonstrating how simple design techniques can drastically improve development efficiency and the supportability of our code. We will begin with a complex bloated service and walk through how we can apply SOLID principles to improve the design and our productivity.

As a result, you will be armed with code design techniques that will set you up for greatness!

Reactive Extensions for JavaScript, or RxJS, is an extremely powerful library which has become very popular and widely used in modern front-end web applications. It is also an extremely confusing library which has frustrated many developers and is widely misused in modern front-end web applications. In this season, we'll seek to demystify the fundamentals of RxJS, learn how and why to use it, and explore some common use cases.

A curious observation occurred during sprints. My Product Owner (and good friend) would be rushing off to meeting or constantly stressing about work that wasn’t planned. Our Tech Lead (and good friend) and I concluded, he had a Secret Backlog in addition to the team’s Product Backlog.

A Secret Backlog is composed of the things that are desperately important to an individual, but the team or leadership cannot be influenced to work on them. These backlog items have real consequences and strict due dates. They can have significant financial impact if not executed properly or prudently. On the surface these projects require a specific skill set usually only found in the owner. Accordingly, the owner enjoys doing this work making the habit self-reinforcing and addictive.

This presentation hopes to provide clues about Secret Backlogs, allow space for participants to discover them in their companies, and provide the skills to help remediate.

Search Engine rankings can make or break any business. In this talk, Alain will go through how search engines crawl and index content in 2022 and beyond. We will see how to run an SEO audit on a website, what mistakes to avoid, and which best practices to put in place in order to optimize your modern web app or blog to achieve optimal search rankings.

Production can be a scary environment. Sometimes things are working great and sometimes they're a complete dumpster fire. How do you know your current status? How do you know where your problem is or which server is causing the degradation? In this talk we'll discuss a journey from no application performance monitoring(apm) to "good enough to troubleshoot today" apm and where we continued after our tire fire was turned back into a normal day. We'll focus on the abstract types of things to watch for and show how easy retrofitting these abilities can be, but for those curious the examples are built on influxdb, and grafana.

Security vulnerabilities in software are almost always a result of malicious user input. The solution then, of course, is to securely sanitize all user data to avoid any issues. But, in a large application, there are numerous places this sanitation can happen. To name a few, the data can be validated when it first arrives or it can be encoded when it is exported back to the user or sent to a backend service such as a database.

In this session, I will cover the best places to sanitize user data to avoid security issues and the advantages and disadvantages to each approach in your code.

This session is designed to foster strong, mutally beneficial, two-way communications and relationships with your colleagues in Product Management. To do that, the session will introduce aspects of the array of responsibilites a Product team typically has, best practices for partnering with Product, and provocative questions to ask of Product with the goal of working better together.

In this session we will walk through how to build a static site using Statiq, Github, and Azure that is much more than just delivering simple HTML.

Need an API? editable content? authorization? CI/CD? Check check and check. I'll show you to make that static site dynamic with Azure functions, Headless CMS, modern tooling, and Azure Static Web Apps.

Leave this session knowing how you can use your .NET / C# skills to build a blazing fast site that costs almost nothing to run and is a joy to work with.

Last year I presented my metaphor for creating a team of developers using superhero media as the basis for a metaphor. This is the sequel to that strategy because just like all Superhero media, the superhero dev team is now a franchise! Are you ready for merch...? Don't worry if you missed the previous talk! This topic is both a sequel and a reboot. After the first five minutes you'll be all caught up.

Every superhero dev team is going to faced with obstacles. There may be some infighting before the superhero devs come together in the end. Or maybe there are some outside regulations (ie. business decisions, process changes, cross-team communication) coming in to tell the superhero devs how to do their job. But the worst thing that your team of superhero devs must face are the supervillains!

Now who are the supervillains of the dev team exactly? Is it our clients for constantly calling in to complain about a bug that blocks them from using the software or is it the bug itself?! Is it the company leader that forces us to follow an annoying proces or is it that non-optimized process that gets in the way of efficient development work? If you're interested in finding out who are the supervillains and ways to vanquish them, this is the talk for you!

"Hmmm, this behavior is odd." "What's causing this to happen?" "I have no idea what happens to this request after it's processed." Does this sound familiar? Did you agonoize for months trying to find the answer? Did you just sweep it under the rug for someone else to eventually notice? In this presentation I will provide you with some helpful tips to instrument and monitor your code bases and key services that power your software. We'll look into monitoring Apache Kafka, Java SpringBoot apps, Python apps, Kubernetes, Postgres, and more with tools such at Prometheus, Graphna, and Loki. We'll also briefly touch on system observability as it relates to the business domain and how that can lead your internal users to discover opportunities for future product offerings.

So many software development teams rack up technical debt and do not even realize it. But even if you are a more mature team and recognize and maybe even document technical debt, what good is it if you do not take action. Just like in other parts of our life, just because we can accumulate bunches of debt, if we do not take steps to handle it, we will be destined for bad times when that comes due. In this session, we’ll explore technical debt, how to properly document and track it, and – more importantly – how to address it so that it does not cause significant issues down the road.

Innovation is a wicked problem; the actual solution is often unknown until you have found product-market fit. This makes it difficult for developers, designers, scrum masters, product owners, and business leaders to achieve a shared understanding and determine how best to reduce risk, generate learnings, and increase the chances of an innovation becoming sustainable. Drawing on my 12 years at Nebraska Global and Don’t Panic Labs, I will focus on techniques that help teams decompose tough problems, engage in critical thought, move faster, and increase the chances that their vision will successfully become a reality.

Not all aspects of software architecture are glamorous, some are downright stressful and often lead to anxiety and stress. One of such roles is the selection of technology stacks and the decision making that goes into which solution should be utilized.

Even within the Microsoft space in 2022 we have so many different models of development that it is becoming increasily more difficult to make seemingly simple decisions such as which technology stack should be used and why. We are presented with so many options, how do we best analyze and select a platform? This session strives to dive into the decision making process, not necessarily any technology specific solutions. Looking at elements such as:

• Developer experience
• Training ability
• Future growth/patching tolerance
• Performance & Scale requirements
• Environmental requirements
• Time to delivery
• Deployment/update scenarios

All of these, and more, should be considered with each and every technology selection. it is very easy to back yourself into a corner without a proper approach to th decision making process.

At the end of this session attendees will have a framework of understanding with regards to technology stack evaluation and how best to pick a future solution while considering all of the risks/rewards.

Aspect-ratio, :is(), grid... what do you really need to know about modern CSS? Join this session for an overview of some modern CSS features you may have missed or aren't using to their full extent. You'll take away techniques you can use immediately to simplify your stylesheets, make components more extendable, and future-proof your solutions as well as make them more inclusive.

Multiple trends were already applying pressure prior to the pandemic to historical employment norms, yet years of habit and tradition had largely left them unbroken. The pandemic necessitated new ways of working, opening the doors to new exercises of what work is and accelerating its evolution. The result is an era where technologists more than anyone face a historical imbalance between their numbers and the number of opportunities -and incentives- for them to work. The assertion of newfound priorities by many around work / life balance and arrangements, a flood of new cash looking for technology investments, the most expensive and constrained housing market in living memory, and fundamental questions around the 9-5 model are some of the forces feeding into a subtle rewiring of what employer and employees really mean to each other.

In his presentation, Drew will discuss evolving trends in technology employment and how they impact people differently, review the broader trends at play, and share his thoughts on what this very bright future holds.

Tranio tells Lucentio that, “No profit grows where is no pleasure ta’en: In brief, sir, study what you most affect.” While Tranio’s point was to get Lucentio to loosen up for him to “live a little,” this is still a valuable lesson to developers. Your team has worked hard to build the functionality that provides all of your customers’ needs, but how easily have you made it for them to access that? Sometimes building the API is the easy part; making them usable is the hard part. But by adding an API gateway, we can make it easier for customers to access functionality and data provided by your application.

In this presentation, we will look at API gateways in general and how to use them to make your APIs usable. We’ll then go into examples using Azure’s API Management service, which allows you to streamline work in Azure and across hybrid and multi-cloud environments to provide your customers with a single place to work with your APIs.

This talk will demo one threat modeling methodology and how an engineering team is appending to their Secure Software Development Life Cycle. The goal is to create a single platform for communicating architectural risk and planning mitigations within sprints. This will not only address security concerns sooner in a product's lifecycle but establish a trusting relationship between engineering and security teams. As an ever-evolving space, to reduce risk and deploy products to market, this is one additional step any software-focused team can quickly adapt to their practices.

Believe it or not, a Futurama episode and my experiences have led me to create the SLURM Framework which I believe will help you navigate toxic waters of a company's culture. In this talk I provide tips for sensing the environment, learning the telltale signs of negative and dangerous behaviors, understanding how to cope and combat disruptive processes, refactoring the norms and continuously improving, and when it's time to move on. Let's open up the floor for a serious conversation about what I think is the single most important aspect of any company: culture.

In this session the speaker plans to offer real-life examples of successes and failures during his transition from an Engineer to an Engineering Manager. He will share both developer and manager perspectives and offer some advice on how an engineer can plan for a successful transition. Often companies fail to provide enough attention to the development of practical leadership skills for Engineers. In this session, the speaker will share some tools that will help engineers along their leadership journey. This will be an informal session and audience engagement will be highly encouraged!

Love or hate it, typescript is a fast growing language that offers many benefits not yet realized in most javascript environments. This presentation provides an introduction to typescript so you can decide if typescript is right for you.

We'll cover language features, how it transpiles into javascript, and some basics on how to set up your environment.

The Agile Ball Point Game is a fun and exciting way for development teams to explore process flow and gain insights into team interactions. Over the last year, I have administered the Agile Ball Point Game with elementary children, high school young adults and professional adults. Watching and observing these interactions has provided valuable insights in how teams interact, how teams should be structured and what works on teams.

This session will explore and introduce the Agile Ball Point Game, followed by an analysis of what was learned from playing this game with others. Topics will include the significance of suggestion, the value of diverse team composition and the importance of unconventional thinking on teams. The value of micro-optimization will be explored.

Additionally, the concepts of agile gaming will be introduced and expanded on.

https://drive.google.com/file/d/1mUL65QmYmvHFO7VYfNauF43Q9eyFM85j/view?usp=sharing

https://drive.google.com/file/d/1RKgJgbNUTblPceEuLFKrb8cVYWvivvZH/view?usp=sharing

IT Professionals often work in isolation and ignore the large number of other people doing similar work. But there are benefits to connecting with others in your community. In today's presentation, I will share with you how others have helped advance my career and how I connected with them. I'll show you how you can enhance your career by drawing on the experiences of those around you. And how to have fun doing it.

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.