Solution Architect and Developer
Phoenix, Arizona, United States
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.
Area of Expertise
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.
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 "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 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.
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.
We depend on AIs to solve a number of different types of problems for us. Many of these problems have more than one possible solution. How to handle these types of problems in building a modern AI system is something every developer will be asked to do over the course of his or her career. Figuring out the best way to utilize the capacity of a device or machine, finding the shortest path between two points, or determining the best way to schedule people or events are all problems where mathematical optimization techniques and tooling can be used to quickly and efficiently find solutions.
This session is a software developers introduction to using mathematical optimization in Artificial Intelligence. In it, we will explore some of the foundational techniques for solving these types of problems, and use open-source solvers to put them to work in our AI systems. Since this is a session for developers, we’ll keep it in terms that work best for us. That is, we’ll go heavy on the code and lighter on the math.
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.
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.
WebAssembly has opened up a world of new possibilities for building Artificial Intelligences. We now have the tools we need to push sophisticated AI models to the client for execution in any environment. In this talk we will take a deep dive into building AI models for use on the client side. We create AI models using open-source tooling and use Blazor to operationalize those models into WebAssembly running in the client's browser.
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.
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.
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.
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.
In this talk, the speaker and the audience will "pair up" for a coding session which will serve as an introduction to using a Test Driven Development process to build a .NET Core application. We will use C#, Visual Studio, XUnit and MOQ to unit test code to be built both with and without dependencies. We will also highlight some of the common issues encountered during TDD and discuss strategies for overcoming them.
Solution Architect and Developer
Phoenix, Arizona, United States