Twin Cities Code Camp

Spring 2023, Sat, Apr 15, 2023

  • Sean McQuaid

    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.
  • David Washington

    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.
  • Jason Bock

    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#.
  • Todd Gardner

    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.
  • Jason Piemeisl

    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.
  • Dustin Ewers

    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.
  • Rockford Lhotka

    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.
  • Brian Gorman

    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.
  • Jacob Woolfrey

    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.
  • Maddison Bruckelmyer

    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
  • Keith Voels

    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.
  • Jeremy Wagner

    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.
  • Todd Gardner

    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.
  • Ben Spain

    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.
  • Mark Kalal

    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.
  • Guy Royse

    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.
  • Aaron Godin

    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.
  • Alan Wong

    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.
  • Brian Seebacher

    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.
  • Michael Cain

    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.