Nick Scialli is a software engineer at the U.S. Digital Service.
One common frustration when getting the hang of recursion is not understanding why your recursive function is returning undefined.
Sometimes it's necessary to abort a fetch request. In this post, we explore how to quickly do so using AbortController!
In this post, we'll serve a node application in a Docker container.
You may know of the Partial utility type in Typescript, but it turns out we can create our own DeepPartial type through some clever recursive typing.
Sometimes we find that we need to traverse an object and perform some operation on it at some arbitrary depth.
One of my favorite ways to learn how something works is to recreate it. Today, we're going to learn the basics of Redux by creating a simplistic version of it.
Let's look at the concept of debouncing and create a sample debouncing scenario.
Let's create a static site in React and learn how to serve it in a Docker container using nginx.
Typescript can be incredibly helpful when we use some of its more advanced features. In this post, we specify the type of one function argument based on the type of another.
One tool for storing data browser-side we might reach for is local storage. In this post, we'll use local storage in React by rolling our own useLocalStorage hook.
Using Jest Mocks to Prevent Non-Deterministic or Otherwise Changing Components from Continously Resulting in Snapshot DiffsNick Scialli • August 30, 2020 • 🚀 3 minute read
Snapshot testing is great until it's not. Today we'll overcome the common problem of seeing snapshot diffs for non-deterministic or frequently changing components.
Today we look at schema-driven React development to see if we can streamline our development process a bit
One challenge we often face when creating apps is combinatoric complexity. Today, we're going to use a handy helper npm package I created to list all possible permutations of variables we're interested in.
After starting my dev email list about 6 months ago, I have been fortunate enough to get over 1000 signups! Here are some of the methods I have used.
There May Not Be a Better Way to Effortlessly Improve Code Quality than Using Prettier Code FormattingNick Scialli • June 06, 2020 • 🚀🚀 7 minute read
We all want higher-quality code. With Prettier, you can achieve this with minimal effort.
Using modern software development practices enable us to find and fix bugs faster and iterate. This post offers a primer into some of these modern practices.
As we explore the Deno ecosystem, we need to know where we can locate third party modules.
With React Router 5, you can programmatically navigate with using the useHistory hook!
As first adopters tinker with Deno, many people are trying to figure out tooling that parallels what they're used to in node.
In this post, we'll write a deep object change handler that both allows us to specify deep object types and satisfies the Typescript compiler..
If you're coming from a node background, it may not be obvious how to pin dependency versions in Deno.
Today we're going to write our first Deno API server in 60 lines.
Testing is supposed to validate that your app works. If you do some refactoring and your app still works but your tests are failing, are you really testing the right thing?
This post will walk you through writing a todo app in React with Typescript.
In React with Typescript, you may be tempted to roll individual change handlers for each field in a component. Let me show you an easier way!
One of the coolest parts about React Hooks is that you can create your own! In this post, we'll quickly roll our own useWindowSize hook.
While most operating systems ship with built-in screenshotting tools, it's often desired to grab pixel-perfect screenshots. In this post, I'll show you how to do so.
In this post, we roll our own immutable proxy function to prevent object mutation!
One type of programming concept I really like explaining is the type that has an intimidating name but, once you learn it, is actually a pretty simple concept. This is how I feel about memoization.
Thunk is one of those programming terms that sounds intimidating, but many of us are actually familiar with and have used them.
A basic setup for using Typescript with React and Redux.
Pure function is one of those terms that might be intimidating at first, but the concept is actually quite simple. In this post, I'll quickly define what pure functions are and why they're good.
The Symmetric Difference interview question is an interesting one because it can be relatively simple to solve if you can think to use the Set object, or, seemingly very challenging or inefficient otherwise.
An approach to migrating between different versions of a schema that may be foundational to your app.
Let's implement debouncing functionality using Redux middleware!
Context was always a great option for sharing app-wide state such as theming. With the useContext hook, it became even better!
Short-circuit evaluation offers a clean and simple way to conditionally assign variables and handle control flow.
Follow along as I write a custom useDebounce React hook with Typescript.
It may feel fancy to use them together, but can get quite expensive.
In this post, we build something useful (an object validator) using test-driven development!
Memoization is an optimization technique used in many programming languages to reduce the number of redundant, expensive function calls.
State management is challenging. We can make it less challenging by making sure we don’t store any redundant information in our state.
The two-sum interview question is interesting to explore because it has both a brute force logical, solution, as well as a more efficient solution that can demonstrate strong CS fundamentals.
There was recently a lot of excitement surrounding the TC39 Optional Chaining Proposal. This is why!
Learning how to fetch data the right way with React Hooks.
Expermenting with the relatively new React Hooks API to accomplish debounced list filtering.
In this article, I intend to pass along the best advice I ever received for going through a whiteboard interview.
This is a somewhat opinionated curriculum for learning front-end development during 100DaysOfCode.
One topic I have gotten more and more excited about throughout my software development career is quality!