Methodically Migrating from JavaScript to TypeScript

by Sean McQuaid

It's no secret that TypeScript is all the rage in modern web development. With all of the scaffolding tools that exist to support starting a new project with TypeScript, it's never been easier to try it out. However, it can feel very overwhelming to think about the necessary steps to migrate your existing JavaScript project to TypeScript. In this talk we'll explore progressive enhancements you can make to move your JavaScript project to TypeScript without disrupting your team's productivity.

Time traveling chatbots - Adding AI to 1980's robots with ChatGPT

by David Washington

In 1985, TOMY released a toy robot called Chatbot. Just a simple toy, it never got to fulfill its true destiny as a conversational, artificial intelligent, chatbot -- until now. In this talk we bring this robot kicking and screaming into the 21st century. First, we replace it's dusty, cold-war era circuits, with internet-connected microprocessors, then we give it a brain running on a node server that performs speech recognition, speech synthesis, and conversational intelligence with ChatGPT. While you may not have your own Reagan-era robot to recreate this this temporal violation, you'll learn how to add intelligence to node apps for any century.

What's New in C# 11

by Jason Bock

C# is an open-source, mature object-oriented language, used by millions of .NET developers, yet its evolution is still underway. In this session, we'll cover the latest features that have been added to C# 11 and how they work in detail, so you'll know when to use them effectively in your new .NET projects. You'll also see the direction C# may be going with future versions of C#.

Web App Observability - Understanding the Client-Side Experience

by Todd Gardner

Most observability efforts focus on distributed services and cloud architectures, end-users only care that the client-side works for them. In this talk, we'll explore how to make client-side web applications more observable by monitoring session analytics, user experience, errors, APIs, and data integrity directly from real users. We'll cover how web developers, SREs, and DevOps engineers can collect data from the browser, handle noise, and interpret data to make better decisions for users, enabling them to prioritize fixes that have the most impact.

Accessibility: the why and how

by Jason Piemeisl

In this session we will focus on how people with different abilities interact with digital experiences we create. We will discuss the importance of prioritizing accessibility when designing digital experiences, while highlighting some common examples of accessibility mistakes and how to avoid them. The session will wrap up with accessibility best practices and guidance for additional tooling and testing to deliver an improved user experience.

Keeping Up With the Everything: Knowledge Management for Developers

by Dustin Ewers

We live in extraordinary times. Technology has exploded, and we have an ever-growing number of tools, useful APIs, and new frontiers to explore. We are awash in opportunities. The downside of all this amazing (sometimes scary) technology is that no one has time to keep up with it all. While mastering everything is impossible, there are ways to learn what you need while keeping an eye on everything else that's going on. In this talk, you'll learn how to build your knowledge portfolio. Like a gardener, you'll learn how to evaluate new technologies and cultivate your knowledge. To help with the overwhelm, you'll learn how to build your own "second brain" to track the details. Finally, you'll learn how to learn more efficiently. After this session, you'll be in a much better position to ride the waves of our ever-changing industry.

No Silver Bullet: Use the Right Architecture for the Right Problem

by Rockford Lhotka

Although monolithic architectures are making a comeback, the best way to build distributed software solutions is through the use of service-based architectures. These include microservices, dedicated n-tier services, and related architectural models widely used when building comprehensive solutions. In this session you will learn when to implement a system using microservices, and when to use dedicated services. You will also learn when to use sync vs async communication between system components, and the importance of discipline around messaging protocols within your system and with external consumers.

Rescuing your GIT Repositories using Amend, Reset, Revert, Rebase, Bisect, and Cherry-Picking

by Brian Gorman

I just pushed a commit to remote main instead of my branch! Help! We merged two features to main but now only one of them needs to go to production without losing the code for the other one ASAP - what do we do? I messed up my branch on rebase, and I can't figure out what happened, but I think I lost my work, can you help? I accidentally put a secret into GitHub and I need it to look like that commit never happened or I might get fired! In this session, we'll discuss the GIT commands of Amend, Reset, Revert, Rebase, Bisect, and Cherry-Picking to perform surgery on our repository when the stuff hits the fan.

A New Training Environment to Learn Software Testing

by Jacob Woolfrey

A testing environment and training program to teach anyone how to be a better software tester. Letting new or old developers have an opportunity to learn software testing without the risk of braking production.

Effective Unit Testing

by Maddison Bruckelmyer

Talks about an overview of jest and react native testing library, what makes unit testing hard, what makes a unit test slow and what makes an effective unit test

Understanding Async, Await and Task in C#

by Keith Voels

Today Async, Await and Task are ubiquitous in C# code. But why? They simplify asynchronous programming. What is asynchronous programming and why use it? I'll show you! I'll explain asynchronous programming and demonstrate the efficiency gains. Then cover some specifics of Microsoft's Task-based asynchronous pattern including the need for 'ConfigureAwait(false)'. I'll also cover some common pitfalls including why not to use 'async void' methods.

Optimizing Interaction to Next Paint (INP)

by Jeremy Wagner

Did you know that 90% of time spent on most web pages is after page load? In this span of time, users are interacting with your website through a series of interactions such as clicks, taps, and keyboard inputs. The slower your website responds to those interactions, the more likely your users will have a negative user experience. At Google, we’ve invested significant time in developing metrics to assess page responsiveness. The first was First Input Delay (FID), which is a load responsiveness metric that measures the input delay of the first interaction. However, we discovered that we needed a new metric that samples more than just the first interaction—and more than that interaction’s input delay. To comprehensively assess overall page responsiveness, we’ve created the Interaction to Next Paint (INP) metric. INP samples all page interactions, and more than the input delay. In this talk, you’ll learn how INP works, why it matters, how to measure it, and how to improve it.

Hostile JavaScript: Attacking and Defending the Browser

by Todd Gardner

How much JavaScript is on your website? Do you know what it does? No really, have you looked at the code and seen what it does? Probably not. JavaScript controls the client side environment, and we can use it to compromise users, consume resources, and steal data. Yet many websites continue to add scripts without review, audit, or thought. Let's explore what JavaScript can do to a browser, the vectors that JavaScript can get added to websites, and how we can defend against JavaScript attacks.

My Favorite Interview Question

by Ben Spain

What makes a good coding interview question? Is it one that spurs conversation? Does it allow the candidate to show their creativity? Does it match what the candidate would do in the real world? As the interviewer, our task is a challenging one: in a limited amount of time, try and assess if a candidate has good potential, would work well within a team, and would be a beneficial hire for the company. Let's face it though, as software engineers, you MUST be able to demonstrate your skills, with code. In this talk, we will go through a coding exercise process that we found to be very effective. We used this process with 20+ candidates during a very recent, high-velocity staffing period. By sharing our process, our results, and many of our observations, we hope to provide others some great insight that they can take into their own interviews. We believe that both interviewers, and candidates, at all levels of experience, will benefit from this talk.

Developer coding tests – friend or foe?

by Mark Kalal

Love it or hate it, something that is getting more common in software engineering and developer interviews are coding tests. They come in a variety of forms ranging from writing actual program code, to design and “whiteboard” problems. In this session, we'll discuss it from both the employer and employee perspectives, talk about what employers and teams are really looking for, and some strategies for putting your best foot forward.

Memory First: An Introduction to Redis

by Guy Royse

Odds are, you've heard of Redis. Maybe you're a total noob and want to learn all about it. Maybe you've used it to cache an API call or some JSON strings and want to know what else it can do. Maybe you *haven't* heard of Redis and are curious what all the fuss is about. Wanna find out? Join me as I explain what Redis is—a wicked-fast, memory-first database—and why you should care. I'll share with you what it can store, how you can access it, and how you can make sure that what's in memory is still there when the power goes off. We'll explore how you can extend Redis—adding new commands, new data structures, and new capabilities. And, we'll do it both from the command line and from code with examples in C#, Java, JavaScript, and Python. When we're done, you'll know what Redis is and what all the fuss was about. But, more importantly, you'll know how to put memory first to build fast applications and faster experiences.

A Primer on Multitenancy

by Aaron Godin

Building software to serve multiple tenants or customers offers its own set of complex challenges. While there are many ways to address multitenancy in software design and architecture, there are as many tradeoffs to consider. This talk will offer a primer on what multitenancy is, possible software architectures, and review what impact these decisions have on the business and technology.

A Skeptics Guide to React

by Alan Wong

This isn't a sales pitch for React. This is instead a talk about how and why we all have to deal with this "not framework/library" to make all our applications. This will go through the SPA vs. MPA wars, why the industry uses React, The fundamentals how and why React is what it is, State vs. Props, Class components vs. Functional components, Lifecycle methods vs. State Hooks, and (very briefly) React Native. If you just want to know how "to make the button do the thing" at work, this probably is for you.

Simplified, Easy, No Problem: Lessons from a Real-World Cloud Data Migration Project

by Brian Seebacher

The vendors say migrating your data platforms to the cloud is cheap, fast, and easier than ever. How does one separate the truth from the hype? An experienced small-company technologist shares his thoughts and observations from a real-world project that brought a decades-old mission-critical reporting system into the cloud era using a Microsoft stack. We'll delve into the finer points and discuss planning, execution, acceptance, and integration. Also, we'll go beyond the project's traditional "happy ending" to talk about the practical things we learned living with our new system for the past two years.

West Side User Stories

by Michael Cain

How do you turn a feature request into code? Have you ever been lost in meetings with a client trying to figure out what they *actually* want? User Stories for the win! We'll discuss how you can take your client/product owner's ideas and translate them into user stories and even a test suite for your fellow developers.