Most Active Speaker

Bob Fornal

Bob Fornal

Senior Developer with a passion for learning, testing, mentoring, speaking and personal growth. Blessed husband and proud father of two

Columbus, Ohio, United States

My focus is on front-end development: JavaScript, CSS, SVG, AngularJS and Angular, React, and Ionic. I commonly speak about Quality Engineering, Best Practices, and Front-End Technologies.

Owner of Code Squid, LLC.
Senior Solutions Developer II (Front-End) at Leading EDJE, Inc.

"Learning from my mistakes over the decades, I feel that I have become a solid programmer." -- Me

Awards

  • Most Active Speaker 2023

Area of Expertise

  • Information & Communications Technology

Topics

  • JavaScript
  • JavaScript & TypeScript
  • Angular
  • ReactJS
  • React Native
  • Unit testing

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.

Making Regular Expressions Readable

In JavaScript, Regex can be one of the hardest parts to read and understand. Let's look at how this concept can be flipped on its head, allowing comments and readability.

Additionally, we will examine how to use this code both with and without a build system.

Let's Talk About Front-End Build Tools

First, let's examine a custom-built site build tool. Then, we'll move to Angular, Vue, and React and examine their build tools. Finally, we'll look at the build tools themselves and how they can be customized as they are fit into CI/CD pipelines.

Let's Compare Angular, Vue, React, and Vanilla JavaScript

Starting with a simple project design we will look at the various design considerations in several categories (initialization, components, services, event handling, build tooling, and testing) to compare and contrast the various strengths and weaknesses of Vanilla JavaScript, Angular, Vue, and React.

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.

Chopping up Spaghetti (Code)

My father tells a story of chopping up his spaghetti at his first meal with my Italian grandparents. Needless to say this was not popular.

Let's examine code with massive functions and limited organizational structure. This type of code has in impact on understanding and managing the code, as well as fixing bugs, and implementing improvements. Can we take code with almost no structure and refactor, abstract, and correctly test it? Also, how do we ensure that what was working doesn't break during the redesign.

We will be working with live code during this talk.

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.

Imposter Syndrome: Stop the Screaming

Imposter Syndrome is something that we all deal with. Let's discuss what it is, where it comes from, and some basic techniques that can be used to combat it. Over time these techniques let us reduce the volume when Imposter Syndrome crops back up again.

Asynchronous JavaScript (Part 2): We're Half Way There

Single-Threaded JavaScript is a unique world that manages to be much more. Here we will dig deeper into Promises, Async/Await and Reactive JavaScript (RxJS). Using several detailed code examples, we will examine these examples in a unique way to show how these interactions 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 JavaScript and RxJS improves our processes for Asynchronous 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 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.

Let's MacGyver some Data

First, we will delve into some seldom used Excel functionality to generate large JSON data sets from existing data. Then, we will massage that data into something usable with VS Code and Regular Expressions. We will look at several examples of this pairing (VS Code and RegEx).

This unusual toolset will provide some practical tools to make work processes more efficient. These tools will be used more frequently than you would guess on the job.

Fragile Code

Fragile (FRA-GEE-LAY, it must be Italian) Code breaks in bizarre and strange ways that we cannot predict.

When you come across this code, what do you do? Think about making changes in CSS - you change one line and the entire website blows up in interesting and unexpected ways.

In this talk, we will look into the underlying symptoms of fragile code. We will also examine ways to mitigate these issues, immediately and over time. You will have actionable takeaways to work with fragile code and avoid it in new code.

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

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.

Asynchronous JavaScript (Part 1): 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

CodeMash 2023

So you wanna speak at Codemash?
https://www.codemash.org/session-details/?id=398835

January 2023 Sandusky, Ohio, United States

Code PaLOUsa 2022

August 2022 Louisville, Kentucky, United States

Stir Trek 2022

May 2022 Columbus, Ohio, United States

CodeMash 2022

January 2022 Sandusky, Ohio, United States

JavaScript and Friends Conference

August 2020 Columbus, Ohio, United States

Leading EDJE Quarterly Talks 2020

Drawing a Keg in SVG

March 2020 Dublin, Ohio, United States

JavaScript & Friends (Online Meetup)

Single-Threaded and Asynchronous JavaScript?

March 2020 Columbus, Ohio, United States

QA or the Highway

A Lifecycle Of Code Under Test

February 2020 Columbus, Ohio, United States

CodeMash 2020

January 2020 Sandusky, Ohio, United States

JavaScript and Friends Conference

August 2019 Columbus, Ohio, United States

Columbus JavaScript Usergroup

Single-Threaded and Asynchronous JavaScript?
(JavaScript Enjoys Your Tears)

July 2019 Columbus, Ohio, United States

JavaScript & Friends (Angular Meetup)

Offline First with Progressive Web Applications

June 2019 Columbus, Ohio, United States

Leading EDJE Quarterly Talks 2019

JavaScript Enjoys Your Tears

April 2019 Dublin, Ohio, United States

Bob Fornal

Senior Developer with a passion for learning, testing, mentoring, speaking and personal growth. Blessed husband and proud father of two

Columbus, Ohio, United States