Sounds Like Code - programming music

In this session we are creating sound with code. Even if you are not a musician (I'm not unless you count Row, Row, Row Your Boat on harmonica), it is easy to get started making music and sound effects for games, YouTube, presentations or full blown musical compositions.

Using Sonic Pi, we explore powerful yet simple features including Samples, Synths, Envelopes and Threading that can create whatever your imagination dreams up. We will start by translating some very simple sheet music into code. Then we move on to twist, warp, stretch and mash sound into amazing creations.

We also do a little "live coding" which, in Sonic Pi, means to perform live by writing code as the music plays. Instead of strumming a guitar, or beating a drum, you write a block of code and on the next loop iteration it seamlessly plays as part of your performance.

You will walk away with the tools and knowledge to quickly start creating your own music and sound effects or just a new way to have a blast while coding.

Room must be wired for computer audio. Disco ball and backup dancing bonobos encouraged but not strictly required.

.http Files - a developer friendly REST client

.http files may just be plain text, but with IDE or CLI support they become a super-charged REST client with capabilities similar to tools like Postman, but with several advantages.

This session talks about these advantages and dives into the creation, use and features of .http files for documenting, testing and validating HTTP resources. Features like using variables, multi-part form data, request history, pre-request scripts, post-request assertions and much more.

We spend the most time digging into the Jet Brains implementation, both in the IDE and via the free CLI which makes .http files easy to use even if you don't have a Jet Brains compatible IDE. However we will also cover the use of these files in Visual Studio and VS Code and talk a little bit about compatibility between them all.

This session gives you the knowledge to start using .http files to simplify how you test APIs and share these tests with your team.

Imposters! faking endpoints over-the-wire

Faking remote services can be very useful. Maybe you need to build against a service that isn't created yet, mock micro service dependencies, test against an API that only has a production instance or validate a large number of data scenarios that would be difficult to achieve with a "real" instance.

For these reasons and more, Mountebank is the best free, cross platform tool for the job. With it, you can spin up your imposter services and have them respond over-the-wire, just like the real thing.
These imposter endpoints can be instantiated from a configuration file, on the fly based on business logic of an executing test, from any tool that can make a POST or any combination of them.

It works by exposing stubs filtered by predicates that dynamically match a request with a response based on properties you define in the URL, headers, body content, etc. It can even be configured to respond in multiple ways per predicate in a round-robin fashion.

And its not just for HTTP. Mountebank supports TCP, SMTP and other community contributed protocols.

This session shows you how easy it is to harness the power of Mountebank to create and use imposters. We demonstrate starting the tool, spinning up imposters via code or http tool (like postman), employing security, viewing the logs, capturing and validating responses and tearing down when done.

By the end of this session you will have the knowledge to begin leveraging imposters in your testing workflow to gain more confidence in your software.

Modern Web Automation Testing

Modern web applications require a modern tool for automated testing. Something that can handle both mobile and desktop, async operations, shadow DOM, all the browsers and much more.

Enter Playwright. Designed for all the needs of modern applications, Playwright checks all the boxes.

This session is all about getting to know how Playwright works and seeing its features in action. Features like Codegen to generate tests by recording user actions, the Inspector which allows you to step through detailed history, the Trace Viewer that captures detailed execution information, recording videos and screenshots and an overview of the API.

Demos will use Typescript, but this cross platform tool also supports javascript, Python, .NET and Java.

So ditch those flaky tests, grab a tool that has all-inclusive features and enjoy reliable end-to-end testing for building robust web UI's.

How and why to use Dev Tunnels in Visual Studio

Dev Tunnels gives developers a way to make ad-hoc connections between devices that otherwise would not be able to communicate. Have you ever wanted to bring up an application on your phone that is being debugged in Visual Studio? Or wanted to give someone a link to the app you are debugging and cause break points to be hit? Dev Tunnels facilitates this and more.

In this intro to Dev Tunnels, we'll see how to use it, the options that it provides and a quick demo of a real-world scenario - testing a power platform custom connector.

Dev Proxy for simulating API responses, errors and rate limits

Dev Proxy is a Microsoft command line tool that intercepts requests on your dev box. It can mock responses, simulate errors and perform rate limiting - all things that are difficult to do with a "real" API. It gives you the flexibility to observe how your application works when it wanders off the happy path.
This session will get you started using the tool and improving your software quality.

For the DotNoobs! Leveling Up Your C#

So you have some C# experience but you're still a little green. Chances are you are making common mistakes without realizing it. This session will accelerate your experience level in just one hour by pointing out things you will never do wrong again, and do so in an easy to understand way.
We'll cover as many mini-topics as we can in 60 minutes, including:
* What a reference type really is and what it means to pass by reference.
* Using HttpClient correctly.
* Async/Await mistakes.
* Exception Handling.
* Dependency Injection
* Unit Testing
* Visual Studio features you should use.
And more, time permitting !

psst, even experienced programmers might pick up a thing or two...

Debug Like It's Your Job

Being a developer is not just about writing code - that code has to actually work and figuring out why it doesn't is a different mindset than writing it. Debugging is not a prescribed recipe, it is a necessary skill for any developer. While this ability is inevitably gained through experience, there are tips, tricks and techniques you can learn to level up your effectiveness as a programmer right now.

For the novice, student or new-grad, this session takes you through the most common things you don't know yet.

- how to use breakpoints effectively (there's more to it than you think)
- what the heck step-into, step-over and step-out do
- how to view and manipulate runtime state
- how to use your environment's interactive terminal to interrogate your program
- what the stack is and how it contains a wealth of information
- the importance of Known Good Values (KGVs)
- being a good investigator

This session saves you from all of those stackoverflow.com downvotes and "did you even debug this?" comments. Bring a laptop and play along! Your browser tools are sufficient to try out many of the presented concepts.

Postman Delivers! A Deep Dive into API Testing.

Whether you are a tester or a developer of HTTP API’s, chances are you are already using Postman to some degree. Chances are also that you are missing out on some of the advanced goodness. Using only features of the free version, this session introduces you to effective use of these features to save time, reduce errors and share your work.

You learn how to :

- unclutter your collections with environments
- create dynamic requests with the powerful scripting environment
- chain requests (never run a separate utility to generate auth tokens again!)
- data drive an entire suite of tests with just a few clicks.
- backup and share your work
- automate the whole shebang from the command line, optionally with reports
- much more...

Ditch the click/wait/verify/repeat cycle! Many concepts presented here apply to API testing in general, whether you use another tool or test with code only. Save time and gain confidence in your software.

This is an updated version of a presentation that has been well received at various meetups, code camps and conferences. Here is a link to a (free) Pluralsight recording from CodeMash 2020.

Leveling up your C#

A programming language is more than syntax. Behavior and use are idiomatic; to be effective you need to know the nuances of the language. In this session you learn how to easily avoid some of the most common C# mistakes that really make a difference in the quality of your software. Whether you are a junior(ish) developer or you’re coming from another language, there are several common things often done incorrectly, or that could be done better. Some things you will never do wrong again include:

- Async/Await basics: possible duplicate of async/await basics
- Encryption Mistakes: TMI
- Parameters in ADO.Net: What is your quest? “To seek the index”
- Exception Handling: Don’t throw the stack out with the bath water
- By ref Reference Type arguments: I object!
- IDisposable: Knowing when it’s time to let go

Presented previously at Boston and Vermont Code Camps.

Debug Like It's Your Job

Being a developer is not just about writing code - that code has to actually work and figuring out why it doesn't is a different mindset than writing it. Debugging is not a prescribed recipe, it is a necessary skill for any developer. While this ability is inevitably gained through experience, there are tips, tricks and techniques you can learn to level up your effectiveness as a programmer right now.

For the novice, student or new-grad, this session takes you through the most common things you don't know yet.

- how to use breakpoints effectively (there's more to it than you think)
- what the heck step-into, step-over and step-out do
- how to view and manipulate runtime state
- how to use your environment's interactive terminal to interrogate your program
- what the stack is and how it contains a wealth of information
- the importance of Known Good Values (KGVs)
- being a good investigator

This session saves you from all of those stackoverflow.com downvotes and "did you even debug this?" comments. Bring a laptop and play along! Visual Studio will be the main focus but the topics apply to any modern IDE and even the browser dev tools.

A more Visual Studio focused version of the same session I have/will present at Granite State Code Camp, Boston Code Camp and Code Mash 2019.

I've Got a Configuration Secret (and I don't even know what it is)

Keeping secrets safe and out of source code has always been challenging. De-coupling sensitive information like connection strings, certificates and passwords keeps these secrets out of source control where it is all to easy to expose them unintentionally.
This session focuses mostly on .Net Core Configuration and also provides an overview of how to leverage Azure App Service Settings, KeyVault and Managed Identities for Azure Resources to help alleviate this long-standing problem. Additionally we will see how to consume configuration even when you, the developer, don't have access to production secrets.
Demonstrated are three application scenarios - A non-Azure-hosted app, An Azure-hosted app and local debugging.
Time permitting, we will also see some techniques for managing secrets in full-framework applications that typically rely on web.config files.
This presentation gives you the basic knowledge to keep secrets out of source code while still assuring correct production configuration.

60 minutes. Will try to compensate for lack of Internet but ideally should have a strong connection. This session has been well received: https://twitter.com/hutchcodes/status/1112496377009979394

For the DotNoobs! Leveling up your c# (part 2)

So you have some C# experience but you're still a little green. Chances are you are making common mistakes without realizing it. This session will accelerate your experience level in just one hour by pointing out things you will never do wrong again, and do so in an easy to understand way.

If you attended my DotNoobs session before, this is completely new content. If you haven't, each topic stands on it's own and no prior knowledge is assumed or required.

We'll cover as many mini-topics as we can in 60 minutes:

Initialization and execution order of properties, fields and constructors.

Gotchas, behavior and guidance of method overloading.

Why you can't make encryption secure if your app has access to keys. If your app can decrypt, then so can your user!

Working with databinding instead of against it.

What it really means to close an ADO.Net database connection and why you should not try to manipulate the connection pool.

Why Path.Combine() exists and why you should always use it.

Deferred vs. immediate execution of Linq queries and the implications on performance.

Why GUIDs typically make a terrible database primary key.

The myth of Disposable and memory leaks. You are not really leaking memory unless you are writing to unmanaged memory or you are using a poorly written library that does.

Target audience: New(ish) to c#. Applies to developers experienced in other languages.

Azure Dev Ops - An Intro to Build and Release Pipelines

Whether you’ve never taken a look at Azure Dev Ops, or you are confused by the terms Agent, Build, Release, Task, Job, Artifact, etc., this session introduces you to techniques to take control of your software deployments.
Starting with an overview of Azure Dev Ops, we progress through an entire build and release pipeline, learning specifics along the way like defining the Build and adding Tasks to pull the source code, build it and test it. Next, we create an associated Release pipeline and deploy to targets like Dev, QA and Production.
Getting started, even for commercial use, is free for up to 5 users, and it is not just for Microsoft’s Team Foundation Version Control! Dev Ops supports 7 different repository sources including GitHub and supports any language, any project. The demonstration project will be sourced in GitHub and deployed to an Azure App Service live on the Internet.
Attendees walk away with an understanding of how to create basic end-to-end build and release pipelines that eliminate human error and achieve stable, repeatable software releases.

Requires Internet access.

Keeping Configuration Secrets Out Of Source Code

Keeping secrets safe and out of source code has always been challenging. De-coupling sensitive information like connection strings, certificates and passwords keeps these secrets out of source control where it is all to easy to expose them unintentionally.
This session focuses mostly on .NET Configuration and also provides an overview of how to leverage Azure App Service Settings, KeyVault and Managed Identities for Azure Resources to help alleviate this long-standing problem. Additionally we will see how to consume configuration even when you, the developer, don't have access to production secrets.
Demonstrated are three application scenarios - A non-Azure-hosted app, An Azure-hosted app and local debugging.
This presentation gives you the basic knowledge to keep secrets out of source code while still assuring correct production configuration.

Presented at Code Camp NYC 2019 and Vermont Code Camp 11

The Land of az - Azure automation with Powershell and the Azure CLI

The Azure portal is great for reviewing details of your resources and one-time operations. But when it comes to repetitive tasks, you can save time and reduce errors by executing a tested, repeatable process. This session dives into the scriptibility of Azure through the Azure Command Line Interface and the Azure Powershell cmdlets.
We’ll quickly go over installation and general use, including how to accept input from users and other sources like KeyVault. In the case of the Azure CLI, we’ll see how to parse output with JMESPath queries for formatting and for using the results in subsequent commands. Then we’ll see how to execute these commands and scripts from a terminal, the Azure Cloud Shell, Automation Runbooks and even the Azure Android app! Finally, we will introduce Bicep, the new domain specific language for coding ARM templates.
Whether you simply want to have a virtual machine automatically started every morning and stopped every night, or you need to provision complex multi-tenant resource deployments, automation scripting is the solution. This session will give you the knowledge to get started automating Azure right away. If you have an Azure subscription, bring your laptop or mobile device and hack along with me.

Power Apps Component Framework

Don't let Citizen Developers have all the fun! There is a place for pro devs in the Power Platform too. This session introduces the Power Apps Component Framework, which allows you to build code components for model and canvas apps. What are code components? Code Components are user interface objects that you build yourself with custom logic, implemented with typescript. Imagine if the Power Platform lacked a gallery component. You could build that! In this session we will demonstrate a real world component implementation that you can download and use today.

To lay the ground work, we will briefly review the concept of solutions, then we will dive right into the Power Apps command line interface to generate a componet project. We will go over the project assets and the typescript implementation of a custom component that you can use in your apps and even share on AppSource. Finally, we will import this component into a Power App and see how it is used along side all the other UI elements you are already familiar with.

Other conferences include Code Mash, Tech Bash, Agile+DevOps West, as well as numerous code camps and meetups. This session is designed for a 60 minute time slot.

Capture the Flag Challenges Explained

Come join me for this session where we go over the solutions to the Capture the Flag challenges. Whether you've been working on them all week or this is the first you hear of it, we're going to have some fun figuring out the answers to these security-related puzzles. You'll see a little cryptography, a little hacking and a little nonsense.
Even if programming is not your forte, come get a look at what sneaky things can be done with simple tools a little perseverance.

Unit Testing T-SQL with Visual Studio SQL Server Data Tools

The Data storage and processing workload for Visual Studio includes SQL Server Data Tools which is now fairly well known as a way to develop and source-control your database. Not so well-known are the unit testing tools you get access to with this feature.

Applicable to anyone using MS SQL Server that is looking for improving quality and reliability, this session explores how to build unit tests against your stored procedures, functions, triggers and any other T-SQL code. The test project is a standard MS Test project, but the test building experience is much different. You'll see how to generate the project and automatically stub out the T-SQL code to test your database objects. Each of the built-in test conditions will be explained and demonstrated; they include things like validating data set checksum, scalar values, execution time, schema, row count and more. Additionally, how to create your own custom conditions in C# will be demonstrated with a real-world example.

At the end of this session you will have the knowledge to create and use SQL Unit Tests, allowing greater confidence in a traditionally under-tested segment of your code base.

This is a significant re-vamp of a years-old presentation

Getting started with Mountebank : over-the-wire test doubles

Mountebank is the best testing tool you've never heard of. It is a free, open source and cross platform tool for multi-protocol test doubles over the wire. When your code calls HTTP(s) endpoints (or TCP or SMTP and more), Mountebank can stand in for the actual service, allowing you to effectively recreate scenarios that are difficult or even impossible when using an actual running service. These "imposters" are created at any point in your pipeline by sending a request to the locally executing Mountebank service that defines the parameters, predicates and responses to return. This means behaviors can be scripted at runtime and be based on any business logic you define. When your tests are done, simply tear down the imposters. It's OK, because your service fakes are defined as JSON and can be source controlled and stood up in milliseconds for the next run.

Don't spend hours or days standing up an API specifically for testing. Don't wait around for someone else to get an API stood up so you can move ahead with your project. Fake it until you make it!

Building 2D games with Construct

Construct is a low-code, in-browser development environment for creating 2D games. Contrary to what you might expect, the browser based IDE has extreme power and top notch user experience. It is an all-inclusive suite of tools for creating sophisticated games with as much, or as little coding as you desire.

This session will build a simple game from scratch that demonstrates the core features of the platform including movement, animations, sound, scripting and expressions. Even if you are a tried-and-true coder, the event sheet, which provides a code-less interface for defining all of the actions taking place 60 times per second, is a great way to build a complex game quickly.

We will also see how to debug, share and publish games to various platforms. Bring your device along and help me test the game in real time!

Unit Testing Concepts for Beginners

Unit testing gives you confidence in the correctness of the code that you ship and allows you to perform maintenance, add features and do refactoring with lower risk. In order to attain that confidence, you must be adept at building effective tests. Targeting developers that are making the transition from just writing code to taking quality seriously, this presentation will show you what it means to have "covering" tests, the difference between unit tests and integration tests, what dependency injection (DI) is, how DI applies to testing, how to effectively mock dependencies and finally, see an example of automated tests in a build pipeline.
Demos will use C# .NET and Azure DevOps but concepts will be explained in a general way.
Also, there will be a Chuck Norris meme.