## Current Podcast Lineup (July 2022)

I'll cut straight to the chase with my current lineup for those looking for new shows. If you're interested in some more details about the podcasts individually continue reading the sections below.

- The Changelog
- CoRecursive
- Hanselminutes
- Merge Conflict
- .NET Rocks
- Software Unscripted

At this point, you may be wondering why I listen to **SO MANY** different podcasts. My answer to that is that I truly enjoy every one of them. I've shuffled podcasts in and out of my regular rotation for several years and my number one criteria for being included is whether or not I enjoy the episodes and that they keep me engaged.

If you're curious as to how I approach listening or why I find listening to software development podcasts useful, check out this [post](https://aaronbos.dev/posts/software-podcast-dev-growth) that I wrote last year, which also includes the podcasts that I was listening to at that time. TLDR; I have trained my ear to be able to listen effectively at 2x playback speed and I listen as much as possible at times when my mind doesn't need to be focused on a single thing. For example, I listen to podcasts while working out, cleaning the house, doing yard work, and other tasks that allow me to focus my mind on something other than the task at hand.

### The Changelog

[The Changelog](https://changelog.com/podcast) podcast's headline is _"Conversations with the hackers, leaders, and innovators of the software world"_ and they deliver on that headline in every episode. Interestingly enough The Changelog also has a family of podcasts and a few of which we'll be going over later. The Changelog is hosted by Adam Stacoviak and Jerod Santo. They are both great hosts who have the ability to ask thought-provoking questions that lead to interesting conversations with each guest. Every episode involves at least one guest and usually one to two hours of great content.

The Changelog is released on a weekly cadence which makes it very consumable. I never feel overloaded or get behind on their episodes. One of my favorite aspects of The Changelog podcast is that they do a great job of striking the balance between cutting edge and relevant content. Typically you see guests that are relevant for one reason or another within a one to three month window. For example, there was a recent episode about the new desktop programming framework Tauri. While Tauri is relatively new, it isn't so fresh that I had never heard of it. In my opinion, this makes the episodes a little more interesting.

My favorite episode from 2022 is definitely "[Practical ways to solve hard problems](https://changelog.com/podcast/486)" with guest Frank Krueger (who turns out to be a host in another podcast we'll talk about later). If you have any interest in checking out I would recommend heading over to their site or browsing your podcast player of choice. I'm sure they'll have something that sparks your interest (if software podcasts are your thing).

Before ending this section on The Changelog I'd like to plug their other podcasts that I also listen to and highly recommend. I find each of these more narrowly focused podcasts to share the great production quality and content that The Changelog delivers.

- [JS Party](https://changelog.com/jsparty)
- [Go Time](https://changelog.com/gotime)
- [Ship It!](https://changelog.com/shipit)
- [Founders Talk](https://changelog.com/founderstalk)

### CoRecursive

[CoRecursive](https://corecursive.com/) is a software podcast hosted by Adam Gordon Bell. If I had to describe CoRecursive to a stranger I would go with "It's like 'This American Life', except for software nerds". Officially CoRecursive is deemed as a podcast that goes into "the stories behind the code", which can lead to some intriguing episodes. Often times the stories that go into the building of software can be more interesting than the software itself. What kind of challenges did a developer or team have to overcome? Why did the product almost never launch? How did an accidental side project turn into a timeless tool that impacts millions of people? These are the kinds of questions that get answered in CoRecursive and often times they are truly fascinating.

CoRecursive episodes are published on a monthly basis, which definitely makes it one of the more anticipated podcasts in my lineup. I always try to listen to the latest CoRecursive as soon as I can after it's released. Adam does a great job at really making the episode a conversation about the process and stories behind the software. There have been some well-known and not so well-known guests and they're all interesting in their own way.

My favorite episode from 2022 is "[Serenity OS](https://corecursive.com/serenity-os-with-andreas-kling/)" with guest Andreas Kling. The story behind both Andreas and Serenity OS is truly inspiring. It's definitely an episode that I'll relisten in the future. If you're interested in what goes on behind the scenes in producing software, CoRecursive is absolutely worth your time.

### Hanselminutes

[The Hanselminutes Podcast](https://hanselminutes.com/) hosted by Scott Hanselman is a classic podcast geared to really anyone with an interest in technology. With the tag line of _"Fresh Tech Talk from Fresh Faces"_ there is something for everyone. At the time of writing this post, Scott has published 849 episodes of the Hanselminutes podcast with the first dating all the way back to January 2006. The guests that Scott brings on are related to technology, but not all necessarily software development which can make it a nice change of pace from the other podcasts that I've listed here.

The Hanselminutes Podcast is released every week and episodes are typically between 30 and 60 minutes. I've been listening to Hanselminutes for about four years now and truly enjoyed every episode. I think one of the reasons that I have stuck with Scott's podcast for so long is his demeanor as an interviewer. He is calm, asks intelligent questions, and has always done his research prior to the episode.

My favorite episode of 2022 is "[Redefining Imposter Syndrome](https://hanselminutes.com/823/redefining-imposter-syndrome-with-maya-bello)" with guest Maya Bello. I found this episode particularly interesting because I feel that almost everyone suffers from imposter syndrome to some extent, but few acknowledge or discuss it. Maya approaches imposter syndrome in a unique way to turn it from a potential negative to a positive. The Hanselminutes Podcast has been a stalwart in my podcast lineup for years and would highly recommend it to anyone interested.

### Merge Conflict

[Merge Conflict](https://www.mergeconflict.fm/) is a podcast hosted by James Montemagno and Frank Krueger (mentioned previously in the Changelog section). James and Frank's on-air dynamic is what really makes this podcast enjoyable for me. Although the podcast is titled "Merge Conflict" they rarely have conflicting opinions on topics, but definitely differ in their personalities (at least from what I can tell from listening). James currently works at Microsoft and Frank is a solo developer. Both have an interest and passion for .NET technologies, which makes this podcast relevant for those who are interested in .NET.

Along with regular discussions about the current events happening in the .NET landscape, episode topics also include mobile programming, machine learning, AI, drones, and so much more. Merge Conflict episodes come out weekly and their always top of my list. The episodes typically range from 30 to 60 minutes, which is right in the sweet spot of long enough for deeper content, but not too long where it's easy to lose interest.

My favorite episode of 2022 is ["Turning Hacks into Reality"](https://www.mergeconflict.fm/288) in which James and Frank discuss some of their "holiday hacks" (side projects taken up during the holidays) that have turned into more than just a hack. I found this episode especially interesting because I have a few side projects that I've either abandoned or continued on longer than what they're worth. It's always fun to hear thoughts from others who share the same interests as ourselves. If any of this sounds interesting, I highly recommend giving Merge Conflict a shot.

### .NET Rocks

[.NET Rocks](https://dotnetrocks.com/default.aspx) has been in my podcast lineup longer than any other podcast. I started listening in 2017 and have been a consistent subscriber since. The show is hosted by Richard Campbell and Carl Franklin, both very experienced developers. The show typically includes a guest who is involved in the .NET development ecosystem. They have produced over 1800 episodes and are most likely the most popular podcast for .NET developers.

The show releases episodes on a weekly basis and they are usually about 60 minutes in length. Due to their reputation and popularity, Carl and Richard are able to pull in some pretty impressive guests who are influential in the .NET space like Anders Hejlsberg, Scott Hunter, Kathleen Dollard, Mads Torgerson, and many more. The content is always very relevant and produced very well. For podcast listeners that also have an interest in .NET, this one is a must listen in my opinion.

My favorite episode from 2022 so far has been ["Pivoting your Startup"](https://dotnetrocks.com/?show=1791) with Phil Haack. That episode was particularly interesting because Phil talked pretty openly about shifting focus from ChatOps for deployments to customer support built on tools like Slack. It's interesting to hear how people approach those decisions and ultimately make them. In the case of a startup, those decisions could make or break the company's future.

### Software Unscripted

[Software Unscripted](https://twitter.com/sw_unscripted) is a relatively new podcast, which means it's also new to my regular lineup. Each episode is hosted by Richard Feldman and includes a guest. So far most of the episodes have been related to functional programming, which I find pretty interesting. While I don't use functional programming day to day, I find the paradigms and concepts to be valuable to be aware of.

Software Unscripted is released weekly with episode length typically in the 45 to 60-minute range. I have really enjoyed the conversational aspect of the podcast in all of the episodes that I've listened to so far. Richard does a great job of conducting the podcast in a way that feels like a discussion instead of an interview. I find this style to be pretty refreshing.

My favorite episode of 2022 has been ["Dark Lang"](https://podcasts.apple.com/us/podcast/dark-with-paul-biggar/id1602572955?i=1000564157929) with Paul Biggar. If you've never heard of Dark Lang you should definitely check it out. Paul's approach to creating an innovative programming language is quite unique. I highly recommend checking out both the podcast and Dark lang.

## Wrapping Up

Podcasts have truly changed the way that I learn about new and exciting topics in the software world. If you have any recommendations for podcasts I should give a listen, definitely let me know on Twitter.


Over the years podcasts have become integral to my daily routine. In this post, I'll provide an update on my current (2022) podcast lineup along with some details about why I find each podcast interesting or useful. Let's dive in!

My Software Development Podcast Lineup (2022)

## What is SWR?

Before we get into the weeds on how SWR impacts our application development, I think it's useful to explain what it is and its purpose. The acronym `SWR` originates from a well-known cache invalidation strategy known as _stale while revalidate_. The premise behind this strategy is as follows.

- A cached response is returned to the client for a specified amount of time (in seconds)
- The cache should attempt to revalidate (i.e. request fresh data) asynchronously while still serving the stale data
- When the amount of specified time passes, the response is deemed to be officially stale
- In the case of officially stale data, fresh data will be served on the next request

In fact, this cache invalidation is built into the HTTP specification. If you'd like to learn more about the HTTP specifics check out the RFC [here](https://datatracker.ietf.org/doc/html/rfc5861#section-3).

In the context of this post, SWR is referring to a library developed by the wonderful people at Vercel. In its simplest form, SWR can be explained as "React Hooks for Data Fetching", which is exactly what we'll be exploring in this post. In the words of the creators.

> With SWR, components will get a stream of data updates constantly and automatically. And the UI will be always fast and reactive.

I don't know about you but that sounds almost too good to be true. Typically fetching data will involve the `useEffect` hook and that works great for the initial retrieval of data, but the story gets more complicated when more complex scenarios like caching and data store mutation come into play. This is where SWR interjects. The `useSWR` hook provides an extensible interface to retrieve data in the most effective manner possible.

## Using SWR

For the purpose of this post, we will be focused on using SWR in the context of a Next.js application. With that being said SWR is not specific to Next.js. It can be used in any React-based application or framework.

At its core, SWR provides robust functionality for efficiently fetching data. It does so by providing the hook `useSWR` which can be called from a component that is dependent on fetching data. The primary usage of `useSWR` involves providing a "key" and a "fetcher" method. The fetcher method is an async method that accepts the "key" as an argument and uses it to fetch data (i.e. make an API request to retrieve data). There are many options to configure SWR to your needs which range from retry functionality, callbacks, refreshing data, etc., but in this post we'll be focusing on three main features of SWR.

1. Data Fetching
1. Auto Revalidation
1. Mutation

If you'd like to take a complete look at all of the options available with SWR, check out the documentation [here](https://swr.vercel.app/docs/options).

### Data Fetching

SWR makes the task of fetching data relatively simple when compared to other methods like relying on `useEffect`. The great thing about SWR is that it takes care of so much typical boilerplate code that is normally required for fetching data. It really boils down to providing a unique key for fetching and caching the data along with a method that informs SWR on how to get the data. In the following examples, we'll be looking at using SWR to request blog post reactions from a component.

I think the first aspect to consider when using SWR is structuring the key. The key needs to be unique to the app so that caching and mutation can work as expected. In my case, I'll be using the API route including the unique slug for the requested post. The key does not need to be a string, but using the unique post slug seemed a good fit for my use case.

```typescript
`/api/post/reaction?slug=${postSlug}`;
```

The fetcher that I am using is simply wrapping the fetch method accepting the key (URL) and returning the JSON.

```typescript
const fetcher = (url: string) => fetch(url).then((r) => r.json());
```

With the return values of the `useSWR` hook, we are able to provide experiences for success, loading and error states out of the box. The current example is a rudimentary implementation of state handling, but it can be as robust as needed for the given use case.

```typescript
const fetcher = (url: string) => fetch(url).then((r) => r.json());

export default function ReactionRow({ postSlug }: Props) {
  const { data, error } = useSWR(
    `/api/post/reaction?slug=${postSlug}`,
    fetcher
  );

  if (error) {
    // Can do something more with the error
    return <div>Error</div>;
  }
  if (!data) {
    // Default to this while the request is being made
    return <div>Loading</div>;
  }

  return <div>{data}</div>;
}
```

Before moving on to the next section one really interesting feature of data fetching with SWR is the ability for it to recognize duplicate requests and only make a single request to hydrate the data. To demonstrate this let's say we have a component (or multiple) that uses the `ReactionRow` component which uses `useSWR` twice (invoked with the same key). Instead of making two API requests to the server, only one request will be made but both component instances with have the necessary data.

![component-screenshot.png](https://res.cloudinary.com/aaron-bos/image/upload/v1657596975/component_screenshot_595dd31393.png)

When the page is loaded, we see the slug displayed twice but only a single API request in the Network tab.

![browser-screenshot.png](https://res.cloudinary.com/aaron-bos/image/upload/v1657596976/browser_screenshot_f370bd225b.png)

### Auto Revalidation

Now that we have a solid understanding of the out-of-the-box functionality of SWR we can jump into a couple of features that I found interesting while using it. First up is "auto revalidation". Auto revalidation is an option that can be specified on a request-to-request basis or globally. Its purpose is to allow the user to configure the frequency at which SWR attempts to revalidate data via the provided fetcher method. By default, SWR does not automatically revalidate data. Let's take a look at a quick example of how we can configure SWR to revalidate our data every second.

We'll be using the same example code as last time except we'll make a quick update to make the returned data a little more obvious that it has been revalidated. As you can see from the GIF below the fetcher is used to make an API request (which now returns a timestamp in the request) and the components are updated based on the fresh data.

![auto-revalidate-swr.gif](https://res.cloudinary.com/aaron-bos/image/upload/v1657596976/auto_revalidate_swr_78e5e81ef5.gif)

There are many other revalidation strategies available in SWR and I definitely recommend heading over to the docs to see if any fit your particular use cases!

### Mutation

To this point, we've spent most of the time looking at fetching data. In most applications where fetching data is required, there is also the possibility of that data changing. As we've just seen we can use auto revalidation to refresh data on certain events or intervals, but what if we wanted to update data right when it changes? That is where "mutations" come into the picture.

SWR provides a few options for mutation revalidation and the one we'll be looking at simply mutates the data and immediately updates the cache and prompts any `useSWR` hooks with the mutated key to update. There are also options to update optimistically before the fetcher function returns, which can be useful if you have a mutation that takes a bit of time but don't want the user to wait for the UI to respond.

Let's look at an example in which we've added a button to the previous code along with importing the global `mutate` function from `useSWRConfig`. The `mutate` method is provided the key to mutate in the `onClick` property of the button. As you can see from the GIF the UI is updated based on the response of the API request each time the button is clicked.

```typescript
import useSWR, { useSWRConfig } from "swr";

interface Props {
  postSlug: string;
}

const fetcher = (url: string) => fetch(url).then((r) => r.json());

export default function ReactionRow({ postSlug }: Props) {
  const { mutate } = useSWRConfig();

  const { data, error } = useSWR(
    `/api/post/reaction?slug=${postSlug}`,
    fetcher
  );

  if (error) {
    // Can do something more with the error
    return <div>Error</div>;
  }
  if (!data) {
    // Default to this while the request is being made
    return <div>Loading</div>;
  }

  return (
    <>
      <div>{data}</div>
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white py-1 px-2 rounded"
        onClick={() => mutate(`/api/post/reaction?slug=${postSlug}`)}
      >
        Mutate
      </button>
    </>
  );
}
```

![mutation-swr.gif](https://res.cloudinary.com/aaron-bos/image/upload/v1657596975/mutation_swr_38ce0de06a.gif)

## Wrapping Up

In this post, we went over a lot of cool functionality that SWR provides. If anything here has sparked your interest, I would highly recommend checking it out and giving it a ⭐ on [GitHub](https://github.com/vercel/swr). I'm currently in the process of learning and using it to add post reactions to my blog posts!


Retrieving data is typically a straightforward task. Retrieving data in the most efficient manner can be more complex. This post will dive into how SWR can simplify the process of fetching data while also solving potentially complex problems like performance, caching, data store mutation, and more. Let's dive in!


Effective Data Fetching with React and SWR

## Time: The Universal Constraint

If you've made it this far (_I appreciate you_), you may be wondering why I'm blogging about time management. My answer to that would be, that I honestly believe it is one of the most important skills to have while also continuously looking to improve upon it. In my experience being able to effectively manage time both at work and personally has been the biggest multiplier to my growth and learning.

The main reason why I believe in the importance of time management is that everyone is constrained by the same number of hours in the day. There are 24 hours in a day. For the average person, six to eight hours are spent sleeping and eight hours are spent working. That leaves us with eight to ten hours left to do as we see fit. It seems like a lot, right? Until we factor in spending time with family and friends, eating, exercising, reading, social media, cleaning, binging the latest Netflix series, and even "gray matter time" (the time spent transitioning from one thing to the next). When all the dust has settled we're lucky to be left with a couple of hours. Choosing what to do with that time and having the ability to use it wisely can make a substantial difference in the long run.

Before moving on to the next section I would like to acknowledge that having the freedom to choose what I do in my free time is a privilege that not everyone has the liberty of enjoying. This post isn't meant to belittle or disparage anyone who is in a situation where the demands on their time are vital to their personal well-being or the well-being of others. If you're not able to put some of the strategies discussed into practice right away that is absolutely fine. I hope this post can show that even big things can start small and time spent compounds like interest when applied intentionally. Keep the ideas in the back of your mind and if the opportunity presents itself you'll have some strategies to help kickstart your improvement.

## My Current Strategy

In this section, we'll be going over my current time management strategy, which has evolved over time with quite a bit of trial and error. We'll be focusing on how I manage my time during the work day. I think that strategy will be most applicable to anyone reading because it is quite general. My strategy for outside of work may be useful in bits and pieces, but holistically it is most likely too specific to my personal schedule.

The strategy that I currently employ can be broken down into a handful of sections. Each plays a part in the overall strategy.

1. Leverage a calendar
1. Schedule recurring events
1. Schedule blocks of time to complete work
1. Be willing to adjust

We'll take the time to touch on each of these components separately starting with leveraging a calendar.

### Leveraging a Calendar

This time management component may seem obvious, but it feels worth mentioning. For the longest time in my career, my calendar was simply used by myself and others to schedule meetings based on availability. I never really thought of it as a tool to "own my time". Over a couple of years, I've shifted my perception of a calendar from being mainly for meetings to a tool that allows me to break my day up into meaningful sections. Each section can be handled and accomplished in isolation from others. Once I made this mental shift the next logical step for me was to cut out repetitiveness by accounting for things that I want to do every day automatically. This is where recurring events come into play.

### Schedule Recurring Events

Recurring events are a component of my time management strategy that aligns well with developing good habits. My goal is to keep the number of recurring events that I have on my calendar at any given time to less than 5. I think any more than that risks setting myself up for failure because days can be hectic and constantly ignoring recurring events due to schedule changes makes the recurring event mostly meaningless. I also try to keep recurring events short-lived. I view them as things that are important, but not time-consuming.

For example, currently, my calendar has three daily recurring events. The first is a 15-min period right at the beginning of the day for planning. We'll actually touch on what is done during this time in a later section. The second event is the time immediately after planning for code reviews. I find code reviews to be a great way to start my day and get into the mindset of writing code. Finally, I have a recurring event at the end of the day for wrapping up my day. This may include taking notes on happenings that day or getting some things ready for the following day.

There are surely other things that I do on a daily basis, but I don't always wish to do them at the same time. For example, I always take 30-min to eat lunch, but sometimes that might be at 11:30 and others at 1:45. I'd prefer to schedule that time on a day-by-day basis, which brings us to the next section about scheduling blocks of our own time.

### Schedule Blocks of Time

In the last section, I mentioned that I have a recurring event on my calendar at the beginning of each day for planning out the things I need to accomplish that day. Planning is great, but there needs to be some output from the planning. In my case, that output is specific blocks of time for focusing on things I need to get done in a given day. I have to give a shout-out to Cal Newport's book [Deep Work](https://www.amazon.com/Deep-Work-Cal-Newport-audiobook/dp/B0189PVAWY/ref=sr_1_1?gclid=CjwKCAjwk_WVBhBZEiwAUHQCmULvDFbXaw0aE95ghDDmu0q4NaNKMqyU7EpeWoTaaDAWYTE0CjgXQBoCZ6IQAvD_BwE&hvadid=241618759129&hvdev=c&hvlocphy=9024739&hvnetw=g&hvqmt=e&hvrand=11497247765285615653&hvtargid=kwd-200120106285&hydadcr=22564_10354991&keywords=deep+work+by+cal+newport&qid=1656647417&sr=8-1) on the daily planning and time blocking strategy. Deep Work has a ton of great information in it on how to focus and make the most of your time. If you've made it this far in this post, I think you'll definitely benefit from reading it.

When it comes to scheduling blocks of time to accomplish tasks, I think it's important to be specific when possible. At the same time, I don't get hung up on not being able to provide a lot of detail to a scheduled block during planning. As long as I know what I want to be working on at that time, I can fill in some of the gaps later. My main goal with scheduling this time is to give myself timeboxes to get things done without having to worry about multitasking or thinking about other things I need to do. I don't have to think about other things once I've added the time blocks to my schedule, I can focus on the task at hand.

### Adjust Schedule Accordingly

So far we touched on a few core components of my time management strategy for work. This final component dealing with flexibility is one that I believe is the key to sustaining any time management strategy over a period of time. Everyone knows that work can get crazy sometimes. Unexpected meetings show up on calendars, lose track of time focusing on a task, juggling many Slack conversations, the list of unexpected interruptions goes on and on. So how do we deal with these interruptions? We need to be flexible and adjust our schedule accordingly.

When I say "adjust accordingly" my intention is that we update our schedule to accommodate the unexpected with the least possible disruption to the existing time blocks. There have been times when I've had a few interruptions and I'm ready to just throw away my whole afternoon plan. While this may be tempting, I've found that just rolling with the punches and making minor adjustments to account for interruptions makes it easy to adjust, but also allows us to get back on track once the interruption is finished.

## Wrapping Up

Overall I've spent a couple of years working on this strategy and testing out different ideas. Some have worked well and some have crashed and burned (ie to-do lists). While I hope this gives you some inspiration on new habits or confirmation on existing ones, I'm sure it won't be a one size fits all solution for everyone. As I mentioned earlier in this post, everyone has different schedules and time commitments to contend with. If you have any ideas to throw my way with your approach to time management I'd love to hear them!


The ability to effectively manage our time as software engineers can feel like a superpower. In this post, I am going to share my current time management strategy and go into a bit of depth on how I think it has benefited me throughout my career. My hope is to provide some insight into ideas you can try to improve your time management or to reinforce strategies that you are already implementing. Let's dive in!

Reflections on Time Management

**A quick note before you read further.** This post is the culmination of my learnings in chapter 1 of the online course '[Build a Modern Computer from First Principles: From Nand to Tetris](https://www.coursera.org/learn/build-a-computer)'. If you are taking this course and don't want to see spoilers for the chapter 1 project I would recommend pausing on this post and coming back after you've completed the project. If this doesn't apply to you, please read on 😀.

## Elementary Logic Gates

A logic gate is essentially a logical operation that is performed on one or many binary inputs resulting in binary output. Logic gates are the building blocks of the technology that we use every day. They act as electronic switches in hardware and when composed can result in complex logic circuits resulting in things like registers and computer memory.

Today we are going to be focused on a handful of logic gates which are referred to as **elementary logic gates**. These gates represent the fundamental logic gates that can be used to build larger and more complex circuits. The gates are as follows.

- NAND
- NOT
- AND
- OR
- XOR
- MUX
- DMUX

In order to visualize the result of logic gates based on given inputs, we use a truth table. Truth tables consist of the logic gate input(s) as well as the resulting output for each input. Here is an example of the truth table for the NAND gate. As you can see there is a column representing each input `a, b` and a column for the output `out`.

![nand-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/nand_gate_fce684c767.png)

The interesting thing about these elementary logic gates is that they can all be implemented from NAND gates. So for the purpose of this post (and the referenced course above) the NAND gate will be considered a primitive gate we can use to construct all other logic gates.

With all of this in mind let's take a look at how Boolean Functions relate to elementary logic gates.

## Boolean Functions

So far we've focused on logic gates, which happen to be physical implementations of boolean functions. At its core, a boolean function is a function that operates on binary inputs and returns binary outputs. Boolean functions play an essential role in the specification, construction, and optimization of computer hardware.

All boolean functions have a _canonical representation_ which means that the function can be expressed by at least one boolean expression. The way that we determine the canonical representation can be broken down into a few steps.

1. Identify all of the truth table rows that output 1.
1. For each row in step 1, we `AND` together each literal input (a 1 is left alone and a 0 needs to be negated) to create a term
1. Finally, `OR` together all of the terms constructed in step 2 resulting in a boolean expression equivalent to the truth table

Let's use the `NAND` truth table shown previously and the steps above to determine the canonical representation.

![nand-truth-table.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951370/nand_truth_table_95777e1cbf.png)

1. Rows resulting in `1` are 1, 2, and 3.
1. Now we need to create a term for each row by `AND`-ing together each literal to result in `1`.
   - `(NOT a) AND (NOT b)`
   - `(NOT a) AND b`
   - `a AND (NOT b)`
1. Now we need to `OR` all the terms to get the boolean expression.
   - `(NOT (a AND b)) OR ((NOT a) and b) OR (a AND (NOT b))`

So with all of this done, we can say that the canonical representation is `NAND = (NOT (a AND b)) OR ((NOT a) and b) OR (a AND (NOT b))`. This exercise also demonstrates that all boolean functions can be expressed with `AND`, `OR`, and `NOT` operators. Since we can express each of the operators with `NAND`, this also means that every boolean function can be expressed with `NAND` as well.

## Elementary Gates as Boolean Functions

In the following subsections, we will be seeing diagrams that include a graphical representation, truth table, and boolean function each representing the logic gate being covered.

### NOT

A `NOT` gate with a single input is also referred to as a "converter". The `NOT` gate negates the input, so input of 1 returns 0 and input of 0 returns 1.

![not-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/not_gate_e436324cfc.png)

### AND

The `AND` gate returns 1 when both inputs are 1 otherwise returns 0.

![and-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/and_gate_0791939e48.png)

### OR

The `OR` gate returns 1 when either of the inputs are 1 otherwise returns 0.

![or-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/or_gate_7ac799994c.png)

### XOR

The `XOR` gate returns 1 when the inputs are not equal otherwise returns 0. `XOR` is also referred to as "exclusive or".

![xor-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/xor_gate_bb9281da99.png)

### MUX (Multiplexor)

The next two gates that we'll discuss are a little different. They both have what is called a "selection bit", which is used to output one of the two input bits (known as "data bits").

The first gate that we'll be looking at is the `MUX` or "multiplexor" gate, which accepts two data bits, `a` and `b`, and a section bit `sel`. With `MUX` if the selector bit is 1, then the output is the `b` data bit otherwise the output is the `a` data bit.

![mux-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/mux_gate_6b586e038c.png)

### DMUX (Demultiplexor)

The `DMUX` or "demultiplexor" gate performs the exact opposite operation as the `MUX` gate. It takes a single data input, `in`, and a selector bit. It then outputs two bits whose values are dependent on the value of the selector. If selector is 1 then the output is {a=0, b=in} otherwise the output is {a=in, b=0}.

![dmux-gate.png](https://res.cloudinary.com/aaron-bos/image/upload/v1655951078/dmux_gate_dc2b0895d0.png)

As you can see from the progression of diagrams, all of these gates are built from previously implemented gates. With the fundamental building blocks, we are able to create complex gates that provide all the functionality that we need for building a computer. 

If you'd like to learn more about this, including multi-bit and multi-way variants, I would highly recommend checking out [Build a Modern Computer from First Principles: From Nand to Tetris](https://www.coursera.org/learn/build-a-computer) because you'll learn all of this and much more with a project-based approach.

Boolean functions and logic gates are at the heart of everything we do as software engineers. While it may not always be obvious or apparent, boolean expressions or the result of combining them form the building blocks for much of what we see and use today in technology. In this post, we'll be looking at how we can go from elementary logic gate definitions to boolean functions based on a few principles.

Representing Logic Gates as Boolean Functions

## Types Of Merges

There are two main methods for merging objects, which are **shallow** and **deep**. While this post is focused on the functionality in TypeScript and JavaScript, you'll find similar concepts in many other languages. When merging objects there is typically a target object and one or many source objects that are applied to the target object. The behavior of the merge depends on the type of merge operation being performed.

As we think about merging two objects together it's important to think about the expected outcome for a given scenario. The expected outcome will help guide our decision on which kind of merge should be used. The next sections will touch on details for each type of merge as well as methods to use them in code.

The examples in this post are going to be based on the concept of merging objects representing HTTP requests. There may be scenarios where we have a base request configuration that is used for most requests but can also override properties when necessary. We can use different merge methods to accomplish this.

If you'd like to follow along with the examples interactively check out this [link](https://stackblitz.com/edit/typescript-rmo7vz?devToolsHeight=33&file=index.ts) to a StackBlitz project.

```typescript
interface HttpRequest {
  baseUrl: string;
  url?: string;
  method?: "GET" | "POST";
  headers?: { [key: string]: string };
}
```

### Shallow Merge

Shallow merging of objects is the most common and least complex version of merging objects. The reason for this being is that shallow merging pertains to simply copying property values from one or many objects to another. If a property is a reference type like an object or array, then the reference will be copied instead of creating entirely new objects. The two most common methods of shallow merging in TS and JS are `Object.assign()` and using the `...` spread syntax.

#### Object.assign()

The `Object.assign` method copies all enumerable (`propertyIsEnumerable(prop)` returns `true`) own properties from one or many source objects to a target object. The source object(s) properties are applied to the target object, which is then returned from the method after it has been modified. Since `Object.assign` performs a shallow merge operation, only properties one level deep will be "merged". Any properties deeper than the first level will simply be copied as part of their parent.

```typescript
Object.assign(target, ...sources);
```

Let's take a look at `Object.assign` in the context of our `HttpRequest` interface. In this example, we create the `req` variable with some base values defined for the properties. We then use `Object.assign` to merge another object with the target. I think the key thing to note in the example is that the `headers` property on the source object will completely overwrite the property on the target due to the shallow merge functionality.

```typescript
const req: HttpRequest = {
  baseUrl: "https://test.com/api",
  headers: {
    "x-api-key": "api-key",
    authentication: "Bearer some-bearer-token",
  },
};

Object.assign(req, {
  url: "/users/1",
  method: "GET",
  headers: { "x-api-key": "a different api key" },
});

console.log(req);
```

The resulting object logged to the console looks like this.

![shallow-merge-object-assign.png](https://res.cloudinary.com/aaron-bos/image/upload/v1654990867/shallow_merge_object_assign_eaebba57e2.png)

#### Spread Syntax

`Object.assign` is the classic way to perform a shallow merge on objects. With the introduction of a [proposal](https://github.com/tc39/proposal-object-rest-spread) in ES2018 we now can use spread syntax as a more succinct way to shallow merge objects. In general, the spread syntax (`...`) is used to expand arrays or objects in place where zero or more properties or elements are expected. For the purpose of this post, we'll be focused on the functionality of merging objects with `...`. Just like with `Object.assign` the spread syntax only copies enumerable own properties to the target object.

Let's look at the previous example, but using `...` to merge the objects instead of `Object.assign`

```typescript
const req: HttpRequest = {
  baseUrl: "https://test.com/api",
  headers: {
    "x-api-key": "api-key",
    authentication: "Bearer some-bearer-token",
  },
};

var merged = {
  ...req,
  ...{
    url: "/spread/users/1",
    method: "GET",
    headers: { "x-api-key": "a different api key" },
  },
};

console.log(merged);
```

As you can see from the screenshot below, the result is similar to that of `Object.assign`. The `headers` key is completely overwritten by the source object's `headers` key object.

![shallow-merge-object-assign.png](https://res.cloudinary.com/aaron-bos/image/upload/v1654990867/shallow_merge_object_assign_eaebba57e2.png)

### Deep Merge

So far we've touched on a couple of different methods for shallow merging objects. Shallow merging will fit most use cases, but there are situations where it falls short. A deep merge differs from shallow merging in that object references are not copied from one object to another. The result of a deep merge will be completely new object references with the target object. This behavior may be desired if we want to avoid unintentionally changing values on objects after merging.

While there are some work arounds to accomplishing a deep merge with JS primitives, we're going to be looking at a method from a library called [Lodash](https://lodash.com/), which provides many utility functions that the language doesn't include in the standard library.

#### Lodash \_.merge()

In this section, we are going to be focusing on Lodash's `merge()` method. I don't always recommend reaching for one-off library methods, but deep merging of objects can actually be rather complicated and I think the value that Lodash (or an alternative) provides is worth the extra dependency. What makes this method different from previous methods is that it performs a deep merge of objects instead of shallow. This means that the resulting object shares no references with the source object(s). In order to accomplish this functionality the method recursively navigates source object keys and applies the new values to the target object.

If you'd like to check out the full implementation of `merge()` you can do so [here](https://github.com/lodash/lodash/blob/master/merge.js). The signature of `merge()` is similar to `Object.assign` as it accepts a target object and one or many source objects. It's important to note that the target object will be mutated as a result of the method.

```javascript
_.merge(target, [sources]);
```

Let's take a look at how we can use `merge` to perform a deep copy from our previous examples. As you will notice from the result, the `headers` key is merged differently than it was during shallow merge operations. The `x-api-key` key is replaced by the source object's value, but the target also includes the `authentication` and `Cache-Control` keys. This is a direct result of lodash's deep merge functionality.

```typescript
const req: HttpRequest = {
  baseUrl: "https://test.com/api",
  headers: {
    "x-api-key": "api-key",
    authentication: "Bearer some-bearer-token",
  },
};

_.merge(req, {
  url: "/deep/users/1",
  method: "GET",
  headers: {
    "x-api-key": "a different api key",
    "cache-control": "max-age=604800",
  },
});

console.log(req);
```

Here is a screenshot of the resulting object from `_.merge()`.

![deep-merge-lodash-merge.png](https://res.cloudinary.com/aaron-bos/image/upload/v1654990867/deep_merge_lodash_merge_d2cbace0da.png)

Merging objects can be challenging without a solid understanding of the available options. As with anything the method we choose will depend on the problem to be solved, but hopefully, this post explains the different options in our toolbelt to apply when needed.

### Resources

[Object.assign docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)

[Spread syntax docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax)

[Lodash merge docs](https://docs-lodash.com/v4/merge/)


Merging two objects seems like it should be a trivial problem to solve at face value. Unfortunately, as we'll see in this post, the problem isn't as straightforward as some may think. In this post, we'll be looking at the options available for merging objects in TypeScript (the options discussed will work just as well with JavaScript).

Hey! 👋

My name is Aaron Bos and this is my blog.

Recent Posts