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.

So, You Want to Speak at a Conference

Do you feel ready to speak at a conference like [CONFERENCE HERE] Conference, but aren't quite sure how to start? Are you curious about presenting, but aren't really sure what it takes? Have you submitted talks that aren’t getting accepted and want some feedback on your proposals?

If any of this rings true, then this workshop is for you!

During this workshop you will practice picking a topic, building an outline to refine your ideas, developing an abstract, and selecting a title that represents your talk and draws interest! You will also be exposed to tips from an experienced presenter on creating a slide deck, utilizing the sometimes forgotten about Notes section, and crafting your biography with examples of both good and bad content.

Prerequisites (recommend, not required):

Bring at least one talk idea.
Any previously submitted talks.
Laptop to work on.

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.

Thinking with a Programmer's Brain

I got a question via private message. The original question was ... What do you think can help me think like a programmer apart from working on various examples over time?

Here are the core areas that are important to get that "programmer's brain."

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.

Asynchronous JavaScript: We're Half Way There

Single-Threaded JavaScript is a unique world that manages to be and do so much more. In this presentation we will dig deeper into Promises, Async/Await, Observables, and Signals. Using several detailed code examples, we will examine code in a unique way to show how these tools truly work.

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 the tools and patterns for Asynchronous activity in JavaScript improves our processes for handing data and events making developer's lives less complicated.

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).

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?

Component vs Class Level Unit Testing

React tests at the component level. Angular tests at the class level. Who is right?

In this talk, we will cover what these two types of testing cover and the pros and cons of each strategy. We will examine code that clearly shows the benefits of each of these patterns and discuss ways this will impact your projects.

Is ChatGPT the next Wikipedia?

FROM WIKIPEDIA: Wikipedia is not a reliable source for citations elsewhere on Wikipedia. As a user-generated source, it can be edited by anyone at any time, and any information it contains at a particular time could be vandalism, a work in progress, or simply incorrect.

ChatGPT ...

Are the AI-Overlords taking over? Maybe not.
Is my job in danger from tools like ChatGPT? Not anytime soon.

In this talk, let's cover what ChatGPT can and can't do. We'll take a look at some real examples of code generated and the ideas they sparked. In particular, we'll discuss the benefits that can be gained if it is used appropriately to assist with testing.

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.

Building Bridges: AI Integration with JavaScript Streams

Let's take a look at JavaScript streams and their use in Artificial Intelligence and Machine Learning, particularly with LLMs.

Through this session, we will embark on a journey through the fundamentals of JavaScript Streams with practical examples, exploring their role in facilitating efficient data handling. Presenting data from these systems to the user can be challenging; let's see how we can reduce friction for the end user. This talk will look at leveraging the synergy between AI and JavaScript for building next-generation applications.

This talk will present several code examples that showcase the use of JavaScript streams to consume LLM data rather than the traditional API request/response pattern or integrating WebSockets into the backend and frontend to provide a more useable interface.

Patterns Unpatterned: The Wit and Wisdom of JavaScript

In the intricate world of JavaScript, design patterns serve as a blueprint for solving recurring challenges in software design. But are these patterns inherently complex, or does their intricacy serve a purpose?

Let's delve into several of the more common patterns; examine the code used, why they exist, and what problems do they solve?

Furthermore, we'll broaden our horizon by investigating 'proto-patterns' and 'anti-patterns' -- the lesser-known cousins with their unique roles in the tapestry of JavaScript design.

The following patterns will be featured at the heart of our discussion:

* Constructor
* Module (Closure)
* Revealing Module
* Factory Method
* Prototype
* Singleton
* Observer

Through this session, we aim to unravel the complexity and showcase their pivotal role in crafting elegant and maintainable code.

From Zero to Hero: The Fundamentals of JavaScript Web Components

Web Components are a powerful way to build components and libraries allowing us to maintain consistency across applications.

There are several ways to build Web Components; each with its strengths and weaknesses. Component libraries can be wrapped to provide a consistent design pattern, component tools (like Lit) can be used to create components or libraries, and for the true geeks among us, we can create pure JavaScript components. Pure JavaScript components provide an insight into all Web Components; a glimpse into what drives the Internet.

This deep dive will provide the attendee with a solid understanding of the underlying technologies. We will also discuss the pros and cons behind the other ways to create custom Web Components.

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?

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