Barry Stahl
Solution Architect and Developer
Phoenix, Arizona, United States
Actions
Barry (he/him/his) is a .NET Software Engineer who has been creating business solutions for enterprise customers for more than 30 years. Barry is also an Election Integrity Activist, baseball and hockey fan, husband of one genius and father of another, and a 30+ year resident of Phoenix Arizona USA. When Barry is not traveling around the world to speak at Conferences, Code Camps and User Groups or to participate in GiveCamps, he spends his days as a Solution Architect for Carvana and his nights thinking about the next Arizona GiveCamp, an annual event where software developers come together to build websites and apps for some great non-profit organizations.
Badges
Area of Expertise
Topics
The Total Football Approach to AI: Mastering Combinatorial Optimization
What if your software could think like Johan Cruyff's legendary Ajax Football Club - fluid, adaptive, and capable of finding optimal solutions in real-time? Welcome to the world of combinatorial optimization, where complex problems become conquerable through techniques inspired by one of football's most revolutionary systems.
Total Football revolutionized the sport by treating the entire team as a fluid, interconnected system where any player could dynamically fill any role. This same principle powers modern software systems that must optimize countless moving parts in real-time:
* A ride-sharing platform balancing thousands of drivers and riders
* A cloud infrastructure automatically scaling and placing workloads
* A supply chain system orchestrating global logistics
* An AI system managing real-time resource allocation
Through hands-on demonstrations using Google OR-Tools, you'll learn how to:
* Transform complex business problems into solvable optimization models
* Apply constraint programming to real-world scheduling challenges
* Implement multi-objective optimization for better decision-making
* Build responsive systems that can re-optimize in real-time
* Deploy these techniques in production environments
You'll walk away with practical strategies to tackle problems that seem impossibly complex - from resource scheduling to configuration management to logistics optimization. No advanced mathematics degree required - just a desire to build smarter systems that can adapt and optimize like the best Total Football team.
Whether you're building enterprise scheduling systems, cloud resource managers, or any application that needs to make complex decisions, you'll learn how to harness these powerful techniques to deliver more intelligent solutions with less code.
LLMs Under the Hood
Large Language Models (LLMs) have revolutionized the field of natural language processing, enabling machines to generate human-like text with remarkable coherence. This presentation goes deep into the intricacies of the transformer model, shedding light on the underlying mechanisms that enable these tools to predict tokens and generate text. We will unravel the architecture of these tools, from embedding layers to attention mechanisms, and provide a clear understanding of the processes that contribute to the model's performance.
Beyond the technical deep dive, we will explore practical applications, discussing valid use-cases where LLMs excel, such as chatbots, content creation, and language translation. We will also critically evaluate scenarios where they may fall short or prove unsuitable, addressing common myths and misconceptions.
By bridging technical expertise with real-world application, this talk aims to equip programmers and other software creators with a nuanced understanding of Large Language Models, empowering developers to harness these tools responsibly and effectively. Join us for an engaging session filled with insights and forward-thinking perspectives on one of today's most groundbreaking technological advancements.
LLM Embeddings - Not Magic, Just Math
Embeddings may be the least understood yet most valuable tool to come out of the world of Large Language Models. In this presentation, we will unravel the mystery of embeddings, emphasizing their mathematical foundations and practical applications.
We'll start by discussing what embeddings are, and what they represent. Then we'll explore the variety of tools we have to compare and contrast them, including Cosine similarity and distance, as well as clustering. Then we'll put those tools to use creating powerful applications that go beyond just typical chat and analytics use-cases.
Attendees will leave with a deeper understanding of the mathematical underpinnings of embeddings, practical knowledge of how to use them, and an appreciation for their value in our applications. This session is ideal for developers, data scientists, and anyone interested in the mathematical underpinnings of machine learning and natural language processing.
Eliminating Hidden Dangers to Your Applications: Patterns for Reliable Systems
There is a danger lurking in every system that hasn't taken explicit steps to eliminate it. This under-recognized data killer can cause inconsistencies in your system which can be as difficult to find as they are to correct. Fortunately, recognizing this monster is easy, and there are a number of great techniques you can use to keep it away for good.
In this talk, we will learn about the Dual-Writes anti-pattern: how to spot it, and what to do to avoid it. In doing so, we'll discuss several well-known patterns that when implemented in your microservices architecture, can help prevent the difficult errors often caused by dual-writes so you can spend more time at awesome conferences and less time supporting your applications. We'll review a number of examples in C#, including demonstrations using SQL Server, Cosmos DB and Kafka.
Crafting AI: A Developer’s Guide to Machine Learning
With Machine Learning (ML) making huge impacts across the software industry, it has become almost imperative for developers to understand its principles and applications. Unfortunately, the complexity of some ML models and the mathematical rigor of its algorithms can be intimidating. This talk aims to bridge this gap, making ML understandable and engaging for developers eager to learn this technology from the ground up.
In this session, attendees will learn the foundational concepts of ML by coding their own models from scratch, without relying on pre-trained models like GPT. We'll start with a simple linear regression, a foundational tool to gain understanding of ML's error minimization and training processes. We'll then explain neural networks with a binary classification example. By the end, participants will not only grasp fundamental ML concepts but will also walk away with their own code implementing one of these models. This talk is designed to equip developers with the knowledge and confidence to use Machine Learning in their projects.
.NET Aspire Accelerator: Fast-Track to Cloud-Native Development
This workshop teaches .NET Aspire through hands-on development of a multi-service application. You'll leverage a browser-based frontend communicating with .NET backend services and both SQL and NoSQL databases. The project leverages industry-standard OpenTelemetry for distributed tracing and metrics, configures service discovery for inter-service communication, and uses .NET Aspire's dashboard for monitoring and service health during development. You'll work with containerized dependencies, replace manual connection strings with Aspire's integration providers, and add .NET Aspire's features into an existing application. Additionally, attendees will craft deployments to Azure Container Apps and Kubernetes, leveraging IDE tools and GitHub Actions workflows for CI/CD automation. Attendees leave with a GitHub repo with extensive samples and the courseware to continue learning or apply the knowledge in their own projects.
## What You'll Learn
* **Core .NET Aspire Concepts**: Master the dashboard, integrations, observability, and discoverability of Microsoft's opinionated tool for microservices
* **Microservices Architecture**: Design and implement a multi-service application with browser-based frameworks, .NET backend services, and SQL and NoSQL data stores
* **OpenTelemetry Integration**: Configure distributed logging, tracing, and metrics collection across all services
* **Service Discovery & Communication**: Implement service-to-service communication with automatic discovery and resilient HTTP clients
* **Container Orchestration**: Manage containerized applications and their dependencies with .NET Aspire's orchestration capabilities
* **Configuration Management**: Eliminate manual connection string management with .NET Aspire's integration providers
* **Brownfield Integration**: Learn techniques for integrating .NET Aspire into existing applications and modernizing legacy systems
* **Azure Container Apps Deployment**: Deploy your application to Azure using the "well-paved path" for .NET Aspire applications
* **Alternative Deployment Options**: Explore Kubernetes deployment and other container hosting options
* **CI/CD Pipeline Setup**: Configure GitHub Actions workflows optimized for .NET 9 and .NET Aspire applications
## Target Audience
This workshop is ideal for:
* .NET developers looking to modernize their application architecture
* Software engineers interested in cloud-native development practices
* Architects evaluating distributed application frameworks
* Teams transitioning from monolithic to microservice architectures
## Prerequisites
* Experience with C# and .NET development
* Basic understanding of web application development
* Familiarity with containerization concepts (helpful but not required)
* Laptop with Visual Studio or VSCode, .NET 9 SDK, and either Docker Desktop or Podman Desktop installed
* An Azure account or free trial with sufficient permissions to create compute and storage resources
Patterns for Reliable Microservice Architectures
There is a danger lurking in every system that hasn't taken explicit steps to eliminate it. This under-recognized data killer can cause inconsistencies in your system which can be as difficult to find as they are to correct. Fortunately, recognizing this monster is easy, and there are a number of great techniques you can use to keep it away for good.
In this talk, we will learn about the Dual-Writes anti-pattern: how to spot it, and what to do to avoid it. In doing so, we'll discuss several well-known patterns that when implemented in your microservices architecture, can help prevent the difficult errors often caused by dual-writes so you can spend more time at awesome conferences and less time supporting your applications. We'll review a number of examples including samples using Relational data stores like SQL Server, as well as Non-Relational stores such as CosmosDB and Apache Kafka.
Success with Microservices: The Critical "Cs"
Microservices allow you to build systems that are scalable, flexible, and resilient, but as valuable as they are, they also come with a set of challenges that can derail your development efforts. In this talk, we will dive into the "Critical C's of Microservices" - a framework for guiding important conversations in the design, development, and maintenance of microservices that can help you determine if you should be using microservices, and if so, identify many of the oft-overlooked considerations when building them.
We will cover each of the 6 C's in detail: Context, Consistency, Contract, Chaos, Competencies, and Coalescence. We will drill-in to the goals of each of the conversations including why they are important, as well as patterns and best practices for leveraging them to create great outcomes for your users, your team and your organization.
You will leave this talk with a deep understanding of how to be successful when building systems using microservice architectures. Whether you are new to microservices or an experienced practitioner, this talk will provide you with the tools you need to determine if microservices are right for your use-case, and what you need to consider if you decide to move forward with a microservices architecture.
Genetic Algorithms
Genetic algorithms "learn" to make better decisions by making continuous improvements in strategy based the fitness of that solution for survival. These algorithms are modeled after Darwinian evolution, using random variations in methodology to improve their fitness.
In this talk we walk through an example of how to create a genetic algorithm to learn the best strategy for playing a board game. We'll define the DNA of the game and look at what parameters control how the solution evolves and improves.
Event Storming Workshop
Event storming is a process for modeling a business domain from the perspective of the business experts. It comes out of the Domain Driven Design world and has been used by many with great success. Event Storming can help your team:
○ Build an understanding of a domain
○ Define the scopes and interactions of the components of a system
○ Rapidly discover unknown-unknowns
○ Expose the intricacies of the business domain
○ Identify the areas of greatest risk
The artifacts produced in this process are useful to both the business experts, to help document their domain, and the engineers building systems for that domain, and are completely implementation agnostic.
In this session, we will explore the process of Event Storming. We will define the goals and expected outputs of the process, and walk through a simple example so that you are ready to bring this important practice into your organization.
Defining the Business Domain using Event Storming
Event storming is a process for modeling a business domain from the perspective of the business experts. It has been used by many with great success. Event Storming can help your team:
• Build an understanding of a domain
• Define the scopes and interactions of the components of a system
• Rapidly discover unknown-unknowns
• Expose the intricacies of the business domain
• Identify the areas of greatest risk
The artifacts produced in this process are useful to both the business experts, to help document their domain, and the engineers building systems for that domain.
In this session, we will explore the process of Event Storming. We will define the goals and expected outputs of the process, and walk through a simple example so that you are ready to bring this important process into your organization.
One AI Algorithm that All Developers Should Know
This simple technique that every programmer should know can simplify certain types of problems tremendously, allowing us to find an optimal solution to difficult problems quickly and easily using a mathematical process called Dynamic Programming. In this session, we will run through examples of using this technique to solve several problems, both "on paper" and in code, and apply that knowledge to build Artificial Intelligences that can make decisions on our behalf.
A Developer's Introduction to Artificial Intelligence
There are a number of ways that developers can build systems that make decisions on our behalf. In this introductory course specifically for software developers, we explore a variety of methods used to create Artificial Intelligences. Using demo code written in c#, we will survey the breadth of AI methodologies and develop an understanding of when each might be best utilized. You will also leave with a library of sample code available for reference.
Amazing Algorithms for Solving Problems in Software
Sure neural networks are cool but have you ever used a Firefly Algorithm to find the solution to a problem? How about an Ant Colony algorithm or one of the many other algorithms inspired by nature? In this talk we will see examples of a number of awesome bio-inspired algorithms that can be used to solve problems in software. We'll see how each one works, analyze its strengths and weaknesses, and determine when it is best used. You'll leave with the knowledge you need to solve problems using these algorithms in your language of choice.
Design Patterns for Loosely Coupled Applications
Building loosely coupled applications is critical to creating solutions that follow good object oriented principles. These principles help make sure our applications are testable, maintainable and extensible. In this session we will explore several design patterns that are key to building applications that maintain loose coupling. We start by reviewing a tightly coupled application. Then, we explore several critical design patterns by using them to convert the application into a maintainable and extensible solution that can be validated using unit tests.
Simplify Your API: Creating Maintainable and Discoverable Code in .NET
Developers don't read documentation, this is a fact. It is also a fact that an API that depends on its documentation to get developers to understand and discover its features is at a huge disadvantage in the marketplace. Fortunately, there are some simple, easy-to-use mechanisms for wrapping complex APIs and making their functionality both easy to use, and highly discoverable. Imagine being able to use tools like IntelliSense that the IDE already provides as a way to expose the functionality of your service or library.
In this session we will build a fluent Domain Specific Language interface over an existing API to create an interface that is easy to use and discoverable through IntelliSense. We'll also drill-in to the patterns and techniques that make this amazing transformation possible.
Things Your Dev Team Hopes You Know
Managing a development team or project can be one of the most challenging jobs in any industry. Balancing the needs of the developers, the organization and the users to maximize value for the customers while minimizing costs can be a daunting prospect for even the most experienced executive. How can we produce quality software in a timely and cost-effective manner when the needs of the development team are so different from the needs of the customers, the organization and its managers?
In this talk Barry leverages his more than 30 years of experience as a Developer and Solution Architect to remind us that how we leverage Agile ceremonies, how we use our tooling, and how we utilize metrics can have both positive and negative impacts on our teams. He reviews many of the elements of our Agile processes and identifies their impacts, particularly on the developers and their managers. This talk challenges us to create environments for our development teams that enable them to exceed the expectations of both our users and our organizations.
Barry Stahl
Solution Architect and Developer
Phoenix, Arizona, United States
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top