TypeScript You MIGHT Like

TypeScript isn’t just a stricter JavaScript, it’s a toolkit for writing clearer, safer, and more maintainable code. Many developers simply use it minimally after encountering verbose types, confusing errors, or patterns that feel academic.

This talk takes a different route: dozens practical, real‑world TypeScript examples you can use today without over‑engineering, or over-hauling, your codebase. Through dozens of bite‑sized examples drawn from actual projects, we’ll cover patterns that reduce bugs, tips that keep types manageable, and features you might be overlooking.

Whether you’re a JavaScript developer TypeScript‑curious, or an experienced user looking for new tricks, you’ll leave with ideas you can drop straight into your editor; and a new appreciation for TypeScript that you MIGHT actually like.

Architectural Innovation: Crafting Microservices with Cloudflare

In an age where agility, scalability, and resilience are paramount, microservices have surfaced as a powerful architectural approach. Lets go on an in-depth exploration of how Cloudflare's tools are reshaping the landscape of edge computing infrastructure, allowing microservices to rise as a first-class citizen.

This session uncovers the tooling that allow developers to design a robust, decentralized infrastructure that will meet the demands of modern applications. We'll cover:

* Worker Scripts: Improving performance, reducing latency, and offering rapid response times for global users.
* Key Vaults: Secure sensitive data at the edge, integrating effortlessly with existing architecture.
* D1 Databases: Store and access data efficiently, maintaining high availability and reliability.

Real world examples and a live demonstration will showcase best practices and potential pitfalls to watch out for. This talk will deliver actionable insights and innovative strategies, whether you're building new applications or improving existing ones.

War Games (Into the Thunderdome)

Let's Compare Angular, Vue, React, and Vanilla JavaScript. These are tools, libraries, and frameworks that are used daily. Each has its strengths and weaknesses. We are passionate about what we use.

Documentation, community, installation, build tools, tooling, release cycles, and testing are just a few of the areas that need to be examined. To determine where each is best implemented, we have to look at use cases for individuals during hackathons, on teams, and at the enterprise level. Additionally, things like build size and lighthouse scores need to be covered.

At the end of this talk, you will have a stronger appreciation for the powerful tools available to us today for front-end development in a variety of cases.

A Look Inside Observables

RxJS Observables are one of the more complicated topics I've learned over the past few years. This is something I struggled to understand fully for a few years.

Observables provide support for passing messages between parts of an application. They are a technique for event handling, asynchronous programming, and handling multiple values.

In this talk, we will examine what Observables are and how Observables can be implemented in a clean, testable manner using code examples to dig into the fine details.

Designing Effective Unit Tests for React

React has great tools for Unit Testing component. This doesn’t mean testing is easy. There are still a lot of questions you have to figure out for yourself: How many component tests should you write vs end-to-end tests or lower-level unit tests? How can you test a certain line of code that is tricky to test? And what in the world are you supposed to do about that persistent act() warning?

In this workshop we’ll introduce Unit Testing with React, along with a mental model for how to think about designing your components and tests. This mental model will help you see how to test each bit of logic, whether or not to mock dependencies, and will help improve the design of your components. You’ll walk away with the tools, techniques, and principles you need to implement low-cost, high-value component tests.

Table of contents

- The different kinds of React application tests, and where component tests fit in.
- A mental model for thinking about the inputs and outputs of the components you test.
- Options for selecting DOM elements to verify and interact with them.
- The value of mocks and why they shouldn’t be avoided.
- The challenges with asynchrony in RTL tests and how to handle them.

Prerequisites

- Familiarity with building applications with React.
- Basic experience writing automated tests with Jest or another unit testing framework.

Writing Testable Code

Writing code that can be tested is not an art form. It takes thought and consideration to keep our code in the best possible shape.

Let's take a look at the warning signs with code examples that can make our code harder to test.

* Does your constructor do too much work?
* Are you using collaborator objects?
* Do you have global state or singletons?
* Do your classes do too much?

Come and see what can be done to improve upon or fix these issues.

"You've lost your job. Who do you reach out to?"

The title is a question I got that really solidified this talk for me. It prompted me to reconsider the recommendations I was making from a different angle.

As we know, finding jobs today is challenging at best. Let's find the right job, the right company, and ways to stand out within a crowd of developers. These are thoughts and ideas that have been hardened through Coffee Chats with hundreds of boot camp and college students over several years.

How does all of this impact individuals who are new to the development industry? What are some of the challenges that those of us with decades in the industry will have?

This talk is intended for new or transitioning developers; experienced developers will also find it beneficial.

The Impact of Testing on a DevOps Pipeline

CI/CD pipelines are an integral part of almost any organization today. “It works on my machine” is only valid in a few scenarios. Our code needs to get to other environments: Dev, QA, UAT, and Production. Testing is a recommended part of the pipeline process.

What is the impact of NOT having active testing in your pipeline processes? How do we get testing in place, and how does it affect an organization?

Zero Dependency JavaScript

node_modules; this folder gives most developers anxiety. It's often one of the largest folders in a project. Imagine having dozens of projects, each with it's own massive set of dependencies.

The JavaScript ecosystem is well known for its use of small packages (left-pad anyone?) and being a huge repository spanning more than 3 million open-source packages but what if we could build our JavaScript applications without any dependencies?

Are we seeing a trend toward zero-dependency JavaScript? What does it mean for the future of JavaScript development, what is its impact on security, and what is the overall developer experience?

Ditch your JavaScript for CSS!

Speed is critical in Web Design. There are things done daily on websites that can be managed in CSS as easily as JavaScript—simply faster. Over the years, I have encountered dozens of these patterns.

Let’s look at both sides of these code examples and discuss their pros and cons. Can we (or should we) ditch JavaScript for CSS?

Non-Automated Automated Testing

There are times when simple manual testing and Smoke Testing isn’t enough. Are you doing production releases with hundreds of affected pages? Or are you migrating thousands of pages from one platform to another?

This talk will cover some scenarios and ways to build automation with manual verification steps that can stabilize tricky releases. We will work through a few known scenarios and ways I’ve mitigated these issues in unusual “automated” ways.

Gherkin: Friend or Foe? Re-Evaluating Its Role in Modern Development

Gherkin is a domain-specific language used to define test cases in a human-readable format, primarily for behavior-driven development (BDD). It allows stakeholders, including non-technical team members, to understand and contribute to software specifications. Gherkin uses keywords like "Feature", "Scenario", "Given", "When", "Then", "And", and "But" to structure test scenarios.

Gherkin is probably sabotaging your development process. I've seen it used well ... I've seen it used badly. Let's talk about situations where it can cause significant problems when building automated test cases and how to use it properly.

30ms of Cloudflare Wizardry

The smallest part of Cloudflare is the most powerful!

Let's geek out on an insightful exploration of Cloudflare Worker Scripts, Key Vaults, and beyond based on over a year of deep hands-on experience. This session will unveil how a single line of code can either break production or unlock powerful functionalities.

Prepare for a deep dive into practical techniques, including:

* Dynamically altering DOM elements
* Utilizing URL paths and parameters to customize content and manage routing
* Employing Key Vaults for more than just enhanced security
* Leveraging D1 Databases effectively
* Managing cookies with precision

This talk features a captivating live demo, allowing participants to witness real-time code execution and solutions. Let's hope the WiFi gods smile upon us for an engaging and seamless experience!

Standoffs to Standups: Hostage Negotiations to Code Reviews

I was a Hostage Negotiator for about a decade. As a former Hostage Negotiator, I've found the need to use my skills within the workplace. This talk explores how the principles of high-stakes negotiation translates into everyday professional success.

I've refined a framework that demonstrates how active listening, strategic empathy, and controlled communication (skills essential when lives are at stake) can transform workplace dynamics, salary discussions, and even code reviews.

Attendees will learn practical techniques for navigating technical disagreements, advocating for resources, and building consensus around architectural decisions without creating adversarial relationships.

Whether you are a developer seeking to advance your career, a team lead managing competing priorities, or a technical manager building high-performing teams, this talk provides actionable strategies to achieve better outcomes through negotiation approaches that build rather than damage relationships.

Testing Is Completely Mental!

Software Testing: web know we should do it, we say we do it, but are we implementing it correctly? I've witnessed testing approaches that drove teams to madness and others that brought clarity and confidence. Let's explore the mental approaches that worked and failed at all levels of Quality Engineering.

We will dive into common testing anti-patterns that haunt development teams, examine why seemingly logical testing strategies fail, and uncover the biases that lead us astray.

Among many other things, you'll learn why "100% code coverage makes us less confident as well as practical patterns for maintaining testing sanity at scale.

Whether you're a testing skeptic or enthusiast, join me for an honest conversation about how to make testing work for your team without losing your mind.

Cloudflare for Hackathons

In fast-paced hackathons, speed is critical. This session distills how teams can rapidly leverage the Cloudflare ecosystem (edge caching, Worker, Key Vaults, databases, and Pages) to launch projects under tight deadlines. Attendees will learn actionable strategies, real world tips, and lightweight configurations that maximize productivity - so they can focus on building award-winning concepts.

* Rapid Deployment Tactics – Learn how to get projects online in minutes, with global reach and minimal configuration.
* Performance Boosts – Use Cloudflare caching, CDN, and Workers to speed up prototypes without extra infrastructure.
* Edge‑Ready Innovation – Discover how to run code right at the network edge to wow judges and users.
* Hackathon‑Friendly Tools – Practical tips students and pros can apply immediately in the 24–48 hour crunch.
* Boost Participant Success – Equip teams with tools to focus more on building features and less on fighting infrastructure issues.

Asynchronous JavaScript: Livin' On A Prayer

There is a unique world where Single-Threaded JavaScript manages to be much more. JavaScript interacts with its environment in ways that allow it to handle Asynchronous activities. Using several detailed code examples, we will examine these examples in a unique way to show how these interactions truly work.

This talk has been also called, "JavaScript Enjoys Your Tears" and "Lip Sync To The Async". If you are an experienced developer or new to the field, there is something in this presentation for you.

This session takes a look at how JavaScript manages Asynchronous events and some of the ways developer decisions may work for, or against them.

This discussion will examine the ways that JavaScript coordinates and manages events using several coding examples and we can determine which are the good, the bad, and ... the ugly.

SCRIPT:
"JavaScript Enjoys Your Tears" is an apt title, but does not clearly describe what this talk is about.

"Lip Sync to the Async in JavaScript" was a good title, but had a better one recommended recently.

JavaScript OBVIOUSLY handles Asynchronous activity AND the various engines are Single-Threaded. This talk will examine many of the Asynchronous events and how they are actually handled through the live execution of code.

This talk is one of the most exciting I have ever given. EVERYONE, from the non-programmer to the JavaScript Gurus, has gotten something out of it.

This is a VERY STRONG talk and deserves to be presented at an appropriate venue.

What to Avoid When Writing Unit Tests

“These tests should never have been written. They provide no or little value.” -ME

Testing code has been described as an "art form." It is, but it should not be. Many good patterns should be followed when writing tests. There is even a lifecycle of tests that should be given some attention. There are also many BAD patterns that developers should be aware of so that they can be avoided (or cleaned up).

This session will provide a series of examples of bad front-end tests and how to write them correctly.

* Tests Should Not Be "Well-Factored"
* Keep The Reader In The Test
* Violate The DRY Principle
* Testing Too Much
* Duplication Of Code Logic
* Bad Test Double
* Testing The Mock
* False Positives
* Testing Private Functionality Directly
* Excessive Setup

"I really enjoyed your talk at Code PaLOUsa (2022) yesterday, and so did several of my team members who tuned in online. Our Teams chats were abuzz with how we will be changing our unit test strategy soon! Thanks for the insight!" - Trenton Minch, QA Lead at eBlu Solutions LLC