Choose Your Own Adventure: Develop, Test, and Deploy a Fullstack Application

This workshop will teach you how to develop an Angular frontend along with a Node.JS backend application. These will be developed keeping proper Unit Testing in mind. Then, you will learn about building a proper pipeline to deploy the app to Azure.

Throughout this workshop, we will discuss the pros and cons of various approaches that address the needs of a client.

Store: Bob’s Bobbers (THEMING)
Need images of me, clearly hacked: glow-in-the-dark, on fire, frozen, and more bobbing in the water.

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.

Katas with a Programmer's Brain

Let's explore what Katas are. How do they apply to programming? What can code katas do for a beginner developer, for an experienced developer? In this talk, we'll examine several code kata sites, code that can be generated as solutions, and how these solutions can help us improve our skill effectively over time.

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.

A Whirlwind Tour of SASS

Syntactically Awesome StyleSheets. Let's take a look at how SASS can ramp up CSS through specific hands-on exercises. The exercises will focus on building a basic page with dark mode available. This pre-compiler will cover the use of variables, nesting, partials, modules, mixins, inheritance, and operators (using the SCSS syntax).

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.

Frontend Diagnostics for the non-Frontend

This talk has come about from various interactions I've had with Quality Engineers, Tech Leads, and UI/UX Designers. I find that there is a lot they are missing to be able to help with identifying and tracking issues in a system. In particular, I've seen times when there are intermittent issues and all we get is "it's broke."

We will cover the browser Developer Tools: Console (errors), Network, managing data, Sources (code), Application Storage, Devices, Targeting Elements and Styles.

If you have ever tried to tell a developer what an issue is and in frustration said,"it's just broke," then this talk is for you. When this talk is over, you will have a much deeper understanding of what you can do to help determine where an issue is and get better information to the developers to target that issue.

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.

Active Career Management

Active Career Management: As we know, finding jobs is challenging at best. Let's talk about finding 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 bootcamp and college students over several years.

How does all of this impact individuals that 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 for the new or transitioning developer; experienced developers should consider it, as well.

Angular: Two Worlds in One - Module or Standalone?

Having seen the value of the Angular Module-System, I was unsure of the Standalone Component System. Having built applications in both, I can see some value in each of the approaches.

Realize that these two ways of doing things can be integrated.

Let's discuss the possible upsides and downsides of each. The correct approach or approaches are not as clear as they seem.

Node Test Runner Workshop

How do you test Node.js applications? The Node.js Test Runner is a stable, modern, fast, and doesn't require additional libraries. But understanding and using it well can be tricky. Attendees will learn how to use Node.js test runner to its full potential. You will see how it compares to other tools, how to set it up, and how to run your tests effectively. During the workshop you will get comfortable with filtering, native assertions, running parallel tests, using CLI, and much more. We will also talk about working with TypeScript, custom reporting, and code coverage.

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?

Component and Unit Testing Do Work Well Together

You've built a React Component to display and manage a list of records on a page. The component turned out the be 600+ lines of code. Now, you're sweating the requirement to have this component solidly tested.

You know that the component will only grow and become more complex over time. The stress to get the code feature complete is building. The clock is ticking ...

Let's tear it apart, rip it up, and shred the code. We’ll refactoring our component in a way that allows for much simpler Unit-Level and Component-Level Testing. This will absolutely go a long way to reduce your stress and increase your confidence in the code going out.

This will be a live-coding presentation.

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?

Crafting a Career-Supportive Reliable Network That Lasts

Success as a developer is rarely a solo journey. Building a strong network that can provide support, resources, and, especially, opportunity is critical. This type of network will allow you to navigate challenges and seize growth opportunities. Let's talk about identifying and connecting with individuals who can elevate your career, sustain meaningful relationships over time, and create a two-way support system that fosters long-term success. Whether starting or looking to fortify your existing network, this talk will empower you with tools to craft connections that last a lifetime and serve as a cornerstone for your career growth. This session is designed for professionals at any stage of their career who are ready to unlock the strength of a strong network.

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.

Let's Replace React with WordPress

Yes. I cringe a bit when I hear WordPress.

At the same time, I have a client who’s deeply invested in both React and WordPress. I've used and worked with WordPress almost as much as React in my time as a developer. Let's walk through WordPress's strengths and weaknesses and see if it's a better alternative than React.

Testing means Slower Development to Business

Unit, Component, Integration, End-to-End, Smoke, Automated, Manual, DevOps, Security, Split Tests, and Pipeline Testing.

All of these slow down code development and releases. Business wants Split Test in production. How much do we need? At what scale do these things become important? Can't we simply write code and merge it to production?

In this talk, we'll take an exploratory approach to almost all testing from a business perspective.

Angular [Is|Might Be|Should Be] Your Go-To Framework

The Angular Renaissance: Angular has been undergoing some significant changes. In this talk, we will delve deep into the modern iterations of Angular, exploring the pivotal updates and innovative features that have redefined its architecture and rejuvenated its ecosystem. It is now a solid framework that is shaking things up.

Why should we as front-end developers revisit Angular?

The opinionated, TypeScript-based framework has changed significantly since the days of AngularJS and more importantly since Angular 2.0. As a result, Angular is becoming substantially more friendly to developers. Angular has always been a strong tool for large, enterprise projects that cross multiple teams. Now, the same can be said for smaller projects, as well.

Angular [can|might|should] become a strong tool in your arsenal.

This session will cover:

* A historical overview of Angular's evolution and the significant milestones that marked its growth.
* An analysis of what's changed in Angular's cutting-edge features and how that impacts us as front-end developers.
* Real-world examples of how to leverage Angular's capabilities by examining the code.

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. There are many good patterns that should be followed when writing tests. There is even a lifecycle of tests that should be paid 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