I’ve come across \`useImparativeHandle\` and \`forwardRef\`s here and there, but never thought much about them. Recently, I stumbled across them again and decided to look into them a bit. As usual, I could have definitely used these in the design of controlled components in the past to simplify the passing of state and functionality between child and parent. Jeez.



\`useImpartiveHandle\` allows us to define functions to be exposed through a ref, which parent components can use.



\`\``javascript

import React from 'react';



import { forwardRef, useEffect, useImperativeHandle, useRef } from "react";



const SomeComponent = forwardRef((props, ref) => {

  useImperativeHandle(ref, () => {

\    return {

\    functionToCall: () => console.log("Calling a child component's function")

\    };

  }, \[]);



  return <p>SomeComponent</p>;

});



export function App() {

  const childComponentRef = useRef();



  useEffect(() => {

\    if (childComponentRef.current) {

\    childComponentRef.current.functionToCall();

\    }

  }, \[]);



  return (

\    <SomeComponent ref={childComponentRef} />

  );

}



// Log to console

console.log('Hello console')

\`\``


Using useImperativeHandle to Access Child Component Functionality


Recently, I've been building a circuit which uses an ATMega328P-PU. In order to run code on the microcontroller, it must first have a bootloader installed on it. The ones I bought do not have it installed, so it's left to me. After following the Arduino guide for burning a bootloader, I've run into various problems. In this guide, I will show you how to successfully burn a bootloader onto an ATMega328P-PU without a external crystal on a Arduino Uno R3 and the issues I ran into along the way.

# Hardware

- Microcontroller: ATMega328P-PU (without an external crystal)
- Elegoo Arduino Uno R3
- Arduino IDE 2.x

# Setup

First we need to install MiniCore (steps are on the [Github page](https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json)). This adds support for the ATMega328 and options to select a clock and other settings.

# Burn Bootloader on ATMega328P-PU

## Setup Arduino Embedded Microsoft as ISP

Before burning the bootloader, we need to setup the Arduino's embdedded microcontroller (which is also an ATMega328). We do this by uploading a specific sketch to it before proceeding.

1. `Files > Examples > 11.ArduinoISP > ArduinoESP`
2. Click the `Upload` button with the `Arduino Uno` board selected

This allows us to use the embedded microcontroller as a an ISP (in-system programmer) in the following steps.

## Setup Circuit

Now that we have the embedded microcontroller setup as an ISP, we have to setup our circuit on a breadboard and place our ATMega328P-PU. This will allow us to communicate with it from the Arduino (so that we can burn the bootloader and program it).

- Ensure there's a 10nanoF capacitor with negative leg in ground and positive in reset on Arduino. This resolved one of my errors mentioned below.

![](/img_2707.jpg)

![](/img_2708.jpg)

![](/img_2709.jpg)

## Burn Bootloader onto External MC

Now that the external microcontroller is setup the Arduino, it's ready to have the bootloader burned on it.

Make sure the following settings are chosen:

![](/settings.png)

1. Click `Tools > Burn Bootloader`

**Note: Ensure debugging mode is on Arduino IDE, so script commands can be copied if your encounter any of the errors below.**

## Upload Code to ATMega328P-U

1. Open the sketch you want to upload
2. `Sketch -> Upload Using Programmer`

# Errors

## 1. Failed connection (device signature 0x000000)

At first, I was receiving an error when trying to write to the MC. It was saying the device signature was 0x000000. Which seems to mean there's an issue with the connection. To solve this problem, I added a 10uF capacitor between the reset and ground. The positive terminal in the reset and negative in the ground.

## 2. Incorrect Signature

After resolving the first issue, the device signature came up, but it was incorrect. So, burning the bootloader and uploading sketches failed. To resolve this, I copied the `avrdude` commands and appended `-F` to force. This worked perfectly!

Arduino IDE is erroring out on a signature error: `avrdude: device signature = 0x1e950f (probably m328p)`. So, we must force each of the commands manually since we know we're selecting the correct MC.

## Workaround for Errors

If running these commands through the Arduino IDE fail, make sure to enable debugging so you can copy the command that's failing. Then you can append `-F` to the end to force the command through.

For example: `"/Users/drew/Library/Arduino15/packages/MiniCore/tools/avrdude/7.2-arduino.1/bin/avrdude" "-C/Users/drew/Library/Arduino15/packages/MiniCore/hardware/avr/3.0.2/avrdude.conf" -v -patmega328 -cstk500v1 -P/dev/cu.usbmodem212101 -b19200 -e -Ulock:w:0xff:m -Uefuse:w:0b11111101:m -Uhfuse:w:0xd7:m -Ulfuse:w:0xe2:m -F`


Burning a Bootloader on ATMega328P-PU without a Crystal (On Arduino Uno R3)


# Multiple Files

In Arduino, splitting out functionality into multiple files is easy. Let's start by assuming we have a file `Main.ino`. We can create other files in the format `<name>.ino` and the Arduino IDE will pick up the files when compiling.

For instance:

```c
// Main.Ino

void start() {
  Serial.begin(9600);
  doSomething(); // works without manually including it
}

void loop() {}
```

```c
// Testing.Ino

void doSomething() {
  Serial.println("Doing something");
}
```

The only caveat is that the extra files need to be in the same directory as `Main.ino`.

# Sharing Enums

When it comes to sharing enums, the above recipe will not work, as we need the enum defined before a file is compiled. But, if using an enum and the method above, when compiling an error will occur where the `enum` will not be defined. So, we must create a header file and include it wherever it's used.

```c
// Main.ino
#include "Types.h"

void start() {
  Serial.begin(9600);
  Serial.println(ButtonType::Solid);
}

void loop() {}

```

```c
// Types.h
enum ButtonType
{
  Solid,
  Gradient,
  Program,
  None
};
```

There may be a better way to do this, but this works. I hope you found these helpful!


Recipes for Splitting & Sharing Code in Arduino IDE


When running a script in a programming language, you have the ability to pass along command line arguments (which can change the functionality of the script upon each run). In node, we can access command line arguments through `process.argv`, which is an array:

```jsx
console.log(process.argv);

/*
[
  '/Users/drew/.nvm/versions/node/v18.16.0/bin/node',
  '/Users/drew/Dev/getThere/src/scraper/scraper.js'
]
*/
```

The the `0th` element is the node interpreter and the `1st` element is the name of the script. From the `2nd` element on, we can grab command line arguments we pass. For instance, say we run `node ./scraper.js fakeCommandLineArgument`.

```jsx
console.log(process.argv);

/*
[
  '/Users/drew/.nvm/versions/node/v18.16.0/bin/node',
  '/Users/drew/Dev/getThere/src/scraper/scraper.js',
  'fakeCommandLineArgument'
]
*/
```

We can then grab our command line argument with `process.argv[2]`. But, this isn’t ideal since the position matters. It would be better if we could pass command line arguments in a manner we’re used to in the CLI like so: `node ./scraper.js --sourceCity=SFO`. We can manually write some functions to parse out the arguments and give them back to use, but there’s already a nice library called [commander](https://www.npmjs.com/package/commander) that does that for us. So, let’s use that.

```jsx
const { program } = require("commander");

program
  .option("-s, --sourceCity <city>", "City to start from")
  .option("-d, --destinationCity <city>", "City to end in");
program.parse();

console.log(program.opts());
// { sourceCity: "SFO", destinationCity: "JFK" }
```

Now if we run `node ./scraper.js --sourceCity=SFO --destinationCity=JFK`, we’ll get back `{ sourceCity: "SFO", destinationCity: "JFK" }` in `program.opts()`. Sweet.

If we want to make these required, thus throwing an error if they are not present, we can use `requiredOption`:

```jsx
const { program } = require("commander");

program
  .requiredOption("-s, --sourceCity <city>", "City to start from")
  .requiredOption("-d, --destinationCity <city>", "City to end in");
program.parse();

console.log(program.opts());
```

If we were to run this without either the `sourceCity` or the `destinationCity`, an error would be thrown:

```bash
error: required option '-s, --sourceCity <city>' not specified
```

Accepting command line arguments can make your scripts more flexible and usable. If you’re using them, throw in commander to provide command line argument parsing and basic presence validation so you can move forward on solving awesome problems instead of manually parsing out command line arguments.


Handling Command Line Arguments in Node


Ever since I began programming in Ruby and was exposed to regular expressions, I’ve always loved using them for string matching. They are incredibly flexible and allow you to easily handle edge cases without ugly conditions or imperative code within loops.

For instance, say we’re looking to parse out hours and minutes from a string that looks like: `2:54 pm+1`, `12:02 am` or `12 am`. If it wasn’t for the last example, we could do something like the following:

```jsx
function getHours(timeString) {
  return parseInt(timeString.split(":")[0]);
}

function getMinutes(timeString) {
  return parseInt(timeString.split(":")[1].slice(0, 2));
}
```

But, since we may not have minutes or a `:` symbol, this doesn’t work for the last example. If we continue without using regular expressions, we would have to handle this edge case. It might look something like:

```jsx
function getHours(timeString) {
  let hours = 0;
  for (let i = 0; timeString.length; i++) {
    if (timeString[i] === ":" || timeString[i] === " ") break;
    hours *= 10 ** i;
    hours += parseInt(timeString[i]);
  }
  return hours;
}

function getMinutes(timeString) {
  let minutes = 0;
  let colonSeen = false;
  for (let i = 0; i < timeString.length; i++) {
    if (timeString[i] === ":") {
      colonSeen = true;
      continue;
    }
    if (!colonSeen) continue;
    if (timeString[i] === " ") break;
    minutes = minutes * 10 ** (Math.floor(minutes / 10) + 1);
    minutes += parseInt(timeString[i]);
  }
  return minutes;
}
```

This isn’t the easiest way to do this necessarily, we could also check if there’s a `:` first before iterating:

```jsx
function getMinutes(timeString) {
  const colonLocation = timeString.indexOf(":");
  if (colonLocation === -1) return 0;
  let minutes = 0;

  for (let i = colonLocation + 1; i < timeString.length; i++) {
    if (timeString[i] === " ") break;
    minutes = minutes * 10 ** (Math.floor(minutes / 10) + 1);
    minutes += parseInt(timeString[i]);
  }

  return minutes;
}
```

So, this is a bit simpler. We could also use recursion to simplify the logic. But, the point is, parsing out sections of a string can be a bit rudimentary. Instead, let’s approach this with regular expressions.

```jsx
const HOUR_MATCHER = /^\d+/;
function getHours(timeString) {
  const match = timeString.match(HOUR_MATCHER);
  return match ? parseInt(match[0]) : 0;
}

const MINUTE_MATCHER = /(?<=:)\d+/;
function getMinutes(timeString) {
  const match = timeString.match(MINUTE_MATCHER);
  return match ? parseInt(match[0]) : 0;
}
```

This is so much cleaner and it handles the case where there are no minutes at all.

Regular expressions are written between slashes like such: `/<regular-expression-here>/`. Then we can use the `match` method on strings to match a regular expression against it. If there's no match, it will return ` null`. Otherwise, it will return an object and the first match will be in the `0` property (similar to how we would access an array, but it's actually an object with a key of `0`).

In `getHours`, we're using the `^` character to latch the regular expression to the beginning of the string. Then we're matching `\d`, which are digits, and then using the `+` character to match 1 or more of them. If there is no match, we'll return `0` hours. But, it would probably be better to throw an error because the `timeString` is in an unexpected format

In `getMinutes`, we're using a positive look behind `(?<=:)`, which checks if there's a matching pattern before the next pattern. In this case, we'll match if there's a `:` symbol. Then, like before, we're matching 1 or more digits with `\d+`. This will stop matching once there are no more subsequent digits (such as a space or end of the string). If the positive look behind isn’t hit (there’s no colon), the match returns `null` and we'll return `0` minutes.

Regular expressions might look a bit cryptic at first, but once you get the basics down, they're actually quite simple. If you're learning to use regular expression, using a [regular expression tester](https://regex101.com/) is helpful when building regular expressions to test them out against various cases to ensure it's working correctly.

I’ve always found regular expressions to be much more concise, flexible and eloquent than manual parsing algorithms based on some pattern. If you haven’t used regular expressions, you should definitely check them out and add them to your toolbox. They're a crucial tool I’ve used countless times and can help simplify your code.


Regular Expressions are Awesome


PM2 is a program that makes managing processes simple. It allows log streaming from multiple processes, auto-restart when a process exits, scheduling, visualization tools and more. We could manually manage our processes by running manual health checks and restarting processes when they don’t respond, but adding this logic to your codebase can be extraneous. Let a process manager do the work for you!

# Setup

First, let’s install PM2. We can do this multiple ways, but if you have node, you can run `npm i -g pm2`. When we use the `-g` flag with npm it installs the library globally so that we can use it without installing it in a specific project. Sweet.

# Starting a Process

By default, PM2 has process restart logic. If we don’t pass a flag, once a process exits, PM2 will restart it. For one-off scripts, this is not the functionality we want. To only run a process once, we can use the `--no-autorestart` flag.

```bash
pm2 start --no-autorestart --name "$source->$destination" node -- src/scraper/scraper.js --from "SFO" --to "JFK" --date "2023-11-07"
```

# Viewing Processes

We can view processes and details about them through `pm2 list`, which lists processes with details at the current time.

![Screenshot 2023-10-06 at 3.18.06 AM.png](/screenshot-2023-10-06-at-3.18.06-am.png)

If you want to monitor processes continually, `pm2 monit` would be a better fit. The process monitor has split panes that shows up to date details on each process and a pane which allows you to inspect output from the process.

![Screenshot 2023-10-06 at 3.37.15 PM.png](/screenshot-2023-10-06-at-3.37.15-pm.png)

# Stopping Processes

If we have long running processes that we want to stop, we can run `pm2 stop <process-name>`.

# Kill all Processes

If we have a ton of stale processes, we can remove them from our process list by running `pm2 kill`

# Process Management + Bash Scripts

Now that we have the ability to easily kick off processes and manage them, we can use a bash script to loop over airports and kick off jobs.

```bash
#!/bin/bash

declare -a airports=(
  "AMS"
  "ATL"
  "SFO"
  "IST"
)

for source in "${airports[@]}"; do
  for destination in "${airports[@]}"; do
    if [[ "$source" == "$destination" ]]; then
      continue
    fi

    echo "Searcing $source->$destination"
    pm2 start --no-autorestart --name "$source->$destination" node -- src/scraper/scraper.js --from "$source" --to "$destination" --date "2023-11-07"
  done
done
```


Easy Process Management with PM2


Recently I’ve been working on an application where I think a graph database would be ideal. Previously, I would have stored records in a RDBMS like Postgresql and constructed a graph in memory. But, this time, I’m working with an incredibly large dataset. So, I’d like to query against it without having to reconstruct a graph in memory upon each server query. Although, I could cache this in memory, why not use a tool which is equipped to solve this problem. Let’s jump into working with Neo4j—a graph database.

# Setup

First we need to download the desktop client https://neo4j.com/download-thanks-desktop/?edition=desktop&flavour=osx&release=1.5.9&offline=false. You can do this at this link.

# Concepts

## Desktop Client

Project files — allows you to save queries/guides and other scripts as cyper files

Favorites — Stored in the Neo4j browser for easy access

## Graph

Nodes - Represent entities of a domain

Labels - Shape domain by grouping nodes into sets. These are used to classify nodes. For instance, City or Airport.

Relationships - connect two nodes. These are also known as edges. These always have a direction. For instance, a flight from SFO to IST can be two nodes which have a relationship of FlightTo which points from SFO to IST. Then, some relationship properties can be added, such as flight price and so on.

Properties - Named values added to nodes and relationships (edges)

## Cypher Language

The cypher language is used for CRUD operations on nodes and edges (relationships).

### Create

First, we can create nodes with `CREATE` like so:

```
CREATE (:Airport {name: "SFO", latitude: 37.6192, longitude: -122.389977})
```

“Airport” is the label for the created entity. This can be anything and other key-value pairs can be added too. `CMD+Enter` can be used to run the operation or you can press the blue play button.

### Read

We can search for nodes with the `MATCH` keyword like so:

```
MATCH (airport:Airport) return airport;
```

“airport” is a variable and can be named arbitrarily. `:Airport` is the same label as we created above in the create statement.

# Querying

Launch the desktop client

![Screenshot 2023-10-03 at 3.31.07 PM.png](/screenshot-2023-10-03-at-3.31.07-pm.png)

Pop open the Movie DBMS and follow the intro guide. It’s incredibly helpful.


Up and Running with Neo4j

# Install openssh server on receiving machine

```bash
sudo apt-get install openssh-server
```

# Ensure SSH Server is Running

```bash
sudo service ssh status
# if inactive run the following
sudo service ssh start
```

# Connect to Server

```bash
ssh <username>@<server-ip>
# for example
ssh drew@10.1.2.2.2
```

The above is a private IP since I'm on the same network at the machine I'm SSHing into. If you are not on the same network

# How to Get Server’s IP

```bash
# run the following on the server
ip route

# default via 10.0.0.1 dev wlan0 proto dhcp src 10.0.0.42 metric 303
# 10.0.0.0/24 dev wlan0 proto dhcp scope link src 10.0.0.42 metric 303
```

Use the IP after `src`. So in this example, it would be `10.0.0.42`. The above example is a private ip. To get a server’s public IP, run the following on it:

```bash
curl ipinfo.io/ip
```


Getting Started with SSH


When there's an existing repository on Github, in order to work on the code, we must first copy it to our local machine. To do that, we use the `git clone command` which allows us to copy a repo from a remote server. In our case, the remote server will be Github.

Before continuing, you may have to authenticate git with Github through SSH. You can learn more on how to do this in my article [Setting Up SSH Through Github](/articles/setting-up-ssh-through-github).

To clone, we'll first need the repository's git url. This can be found in the Github UI and copied by clicking the copy button aside it. It will looking something like `git@github.com:drewrodrigues/pretend-repo.git`.

![Clone Step 1](/clone-step-1.png)

Once we have the Github url, we can use it in the `clone` command as follows:

```
git clone git@github.com:drewrodrigues/pretend-repo.git
```

After the clone (download) finishes, you can run `ls` and you'll see your repo in your current directory. Nice!


Cloning Your First Repo


Node is a runtime environment that allows Javascript to be run outside of a browser. You can think of runtime environments as a fancy way to say an environment in which we can run something. In this case, Javascript on your local machine outside of a browser. Before node, Javascript could only be run in browsers, since browers have Javascript intepreters embedded in them.

Now, setting up `node` is a pretty straight forward process. It involves first setting up a version manager known as `nvm` or "node version manager." This allows us to easily swap between node versions with a simple command line interface. Which is incredibly helpful when you work on various project which may use different node versions. Then, we'll install a version of node through `nvm` and then select it as our default. Let's jump in!

# NVM Setup

`nvm` can easily be installed through the `brew` package manager. If you don't have brew, you can [install it here](https://brew.sh/). Or run the following:

```shell
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

Once you have brew installed, install `nvm` by running:

```shell
brew install nvm
```

Once `nvm` is done installing, you may have to restart your terminal for it to be available in your shell. We can check that `nvm` installed correctly by simply running:

```shell
nvm
```

If it is installed and setup correctly, it should output a helpful guide with common commands and documentation.

# Install a Node Version

If you ran `nvm` in the previous step, you may have noticed it shows you an example of how to install a version of `node`. How convenient!

![nvm help](/nvm-help.png)

Let's install node version `18.16.0`. For you, this version is completely arbitrary, but it happens to my current node version. So, that's what we're running with. If you want to install a different one, swap out the version number.

```shell
nvm install 18.16.0
```

# Selecting Your Node Version

Once the install is complete, we have to select the node version with `nvm`. In this case, we're going to set the default version.

```shell
nvm alias default 18.16.0
```

Now we can test that everything is setup correctly.

```shell
node --version
```

This should output `18.16.0`, or whichever version you installed and set as your default. If it does, awesome job setting up node!


Setting Up Your Node Environment on Mac


I can’t remember a time in my life when I haven’t reflected on what makes a good life. Although I’ve spent considerable time contemplating this, I’ve yet to come to a conclusion. I’m not sure I ever will. But, I would like to make an attempt.

To begin, it’s good to define what a good life means in the first place. This is where much of the difficultly stems, since it’s so subjective. A good life could mean something different to each person, yet not take away from another’s definition. For me, living a good life means living the life one wants to live. Yes, I know, this is incredibly vague. But, hear me out. I promise there’s some substance here.

How often have you heard someone say they want to do something, yet they never go off and find out if they can do it? This might be from self-doubt, lack of motivation or consistency, fear of failure, or potentially down right laziness. Whatever the reason, the premise is that someone wants to do a thing, yet never makes a true attempt at doing it. It’s in this place where I feel a life is not truly lived. Specifically, a life that one wants to live is not lived. If one doesn’t live the life they want to live or even make a true attempt, then really what’s the point of life?

Within our short time here on Earth, in essence, all we have is our effort and direction. We can control these things to fill our lives with whichever experiences we want (to a certain extent). Our life is solely filled with experiences and it’s up to us to choose which experiences we want to fill it with. This is an incredibly responsibility that I feel many take too lightly. Or maybe, one I take too seriously.

If we live a terrible life, filled with negativity, not doing the things we want to do, poor finances and health; we’ve likely had an influence on these things (although, not all of these things we completely control). If we have an exceptional life, filled with great relationships, doing the things we want, positivity, a fulfilling career, good health and the like; it’s also very likely we’ve had a strong influence on this outcome as well. If we don’t take the reigns and understand the control we have on our life direction, we can end up living a life like the former.

If we’re not explicitly directed towards what we deem worth spending our life on, we’re left to drift into the abyss—whichever way circumstances and easiness deems. One might succumb to over consumption and following whatever path others set out for them without much thought. Whatever the direction, it’s not from a place of self-direction. This is sheep being herded. But, the sheep know not where they are going. It’s easy, ignorant and blissful, but I would argue a life mislived.

One might make a half effort attempt and then back down, but this really doesn’t count. For if the person really wanted to do this thing in the first place, it will haunt them to their dying day. One may end up with many half effort attempts, but never truly learning whether or they succeeded or not in this endeavor. Essentially, the want to do the thing will not be satisfied. If we’re on our death bed thinking we didn’t really give it a shot and do the things we wanted, we truly missed out and it’s too late.

This is why I believe it’s essential in life to make true strides towards whatever it is that we want to do. Not from a place of stress and negativity. But, from a place of joy and conviction that we’re leading the direction of our life.

Pursuing what we want, I believe, is a dramatic win in itself. If one truly loves what they are doing, the associated outcomes should not matter. The work in itself is the reward.

This also brings up the hardest question of all: what life do you want to live? This can be an incredibly difficult question to answer for many, but I find it’s important to make attempts, find out what sticks for you and what you enjoy and push towards these things. Albeit, without stress and negativity, but from a place of deep positivity. A life doing what we want, is a rich life that no money can buy.


What Makes a Good Life?


Recently while scraping, I’ve been getting captchas and eventually blocked by websites (occasionally, although I space out my scraping to not overload services). So, my first thought was to use some free public APIs that serve a list of proxies to use. After querying the API, I would then query the proxy to check it’s health. If the server responded to me, I would then attempt to use the proxy. But, most of the time I would get errors:

![Screenshot 2023-10-05 at 11.50.34 PM.png](/screenshot-2023-10-05-at-11.50.26-pm.png)

![Screenshot 2023-10-05 at 11.50.26 PM.png](/screenshot-2023-10-05-at-11.50.34-pm.png)

Essentially, the connection would fail or the request would be refused from the website I’m scraping. Maybe they are blacklisted or being overused by others? Not sure here, but I needed to find something that would work. So I caved and starting looking at paid services. I eventually came across WebShare, which gives you 10 proxies and the functionality to auto rotate them. Pretty sweet. Immediately, this worked! Instead of getting errors, puppeteer popped up without any captchas (for a while of course).

![Screenshot 2023-10-06 at 12.05.26 AM.png](/screenshot-2023-10-06-at-12.05.26-am.png)

```jsx
// scraper.js
const browser = await puppeteer.launch({
  headless: false,
  args: [`--proxy-server=p.webshare.io:80`],
});
const page = (await browser.pages())[0];

// authenticate with proxy
await page.authenticate({
  username: process.env.PROXY_USERNAME,
  password: process.env.PROXY_PASSWORD,
});
```

```jsx
// .env
// this file should be in your .gitignore if you're using git to keep it out of source control
PROXY_USERNAME = "<YourUsername>";
PROXY_PASSWORD = "<YourPassword>";
```


Up and Running with Puppetteer and a Rotating Proxy


# Install Pyenv

First, we’re going to get a version manager. This allows you to easily install and change the python version you’re using.

```bash
brew install pyenv
```

When we install `pyenv`, we still have to add a few lines to our shell profile for it to work in our environment. You can find up to date information on how to do this on [pyenv’s github page](https://github.com/pyenv/pyenv) in the installation section. The following lines should be appended to your shell profile:

```bash
# Appended to the end of my ~/.zshrc
export PYENV_ROOT="$HOME/.pyenv"
command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
```

After appending these lines to your shell profile, make sure to either source your profile with `source ~/.zshrc` or restart your shell. Otherwise, the changes will not affect your current shell environment.

At anytime, you can enter `pyenv` and it will print out a list of the available commands with helpful descriptions. So, don’t worry about memorizing or writing down any of these commands.

# Install a Python Version

Now that we have `pyenv` setup, we can use it to install a version of python.

```bash
pyenv install 3.10.1
```

Now that python version `3.10.1` is installed locally, we have to select it.

```bash
pyenv global 3.10.1
```

We can test that we have python setup correctly by running

```bash
python --version
```

This should output `3.10.1`. Congrats, you setup your python!


Setting Up Your Python Environment on Mac


Not all of these queries will work for you, as you may not have the same extended columns. These should primarily be used as reference and adjusted to your own columns if there are discrepancies.

```sql
-- logs within the last 2 weeks
<table>
| where timestamp > ago(14d)
​
--logs in a minute of time
<table>
| where timestamp between (datetime("12/18/2021, 3:50:10.021 PM" .. datetime("12/18/2021, 3:51:10.021 PM") )
​
--on date 2021-01-02
<table>
| where timestamp > datetime(2021-01-01) and timestamp < datetime(2021-01-03)
​
--pluck out columns using `project`
<table>
| project, message, timestamp, customDimensions
​
--take n rows
<table>
| take 5
​
--ordering by
<table>
| top 5 by timestamp
​
--group count and take top
<table>
| summarize Count=count() by message
| top 5 by Count
​
--distinct sessions by country count
<table>
| summarize Count=dcount(session_Id) by client_CountryOrRegion
| sort by Count desc
​
--add derived column using `extend`
<table>
| extend level=customDimensions.level
​
--count by day
<table>
| summarize count() by bin(timestamp, 1d)
​
--engagement by country
<table>
| where customDimensions.level == 30
| summarize UniqueSessions=dcount(tostring(customDimensions.sessionId)), Events=count() by client_CountryOrRegion
| extend AverageEventsPerSession = Events / UniqueSessions
| sort by AverageEventsPerSession desc
​
--average errors per session
<table>
| where customDimensions.level == 30
| summarize session_count=dcount(tostring(customDimensions.sessionId)),
    event_count=count() by bin(timestamp, 1d)
| extend average_errors_per_session = event_count / session_count
| sort by timestamp asc
| project average_errors_per_session, timestamp
| render columnchart
​
--top error types recent version in pie chart
<table>
| where level == 50 and appVersion == "someVersionHash"
| summarize count() by message
| sort by count_ desc
| take 10
| render piechart
```


KQL Cheat Sheet


In order to authenticate in Github, we must first setup a SSH key. If you're curious about SSH, you can read about it [here](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/about-ssh). The steps we'll be following are simple: generate a SSH key locally, copy the public key to your Github account and then we'll clone a repo to ensure it's working correctly.

# Generate a SSH Key

First, we'll generate the SSH key. Run the following in your shell with your email replaced:

```shell
ssh-keygen -t ed25519 -C "your_email@example.com"
```

It will then prompt you for the location you want to store your SSH keys. Just hit enter, as the default location of `~/.ssh` if fine.

Next, it will prompt you for a passphrase. You can just hit enter if you would like. Passphrases are not required, but they are an extra layer of security.

# Add Public Key to Github

Now that you have your SSH key generated, we have to enter the public key into Github. You can do this by logging into Github and going to `settings`.

![](/github-settings-screenshot.png)

Then navigate to the `SSH and GPG keys` section and click on the `New SSH Key` button.

![](/ssh-step-2.png)

At this point, you can enter a title such as `Macbook Air` or whatever you would like as an identifier. Then copy your public SSH key into the `Key` field. You can get this by running the following command in your shell. It will copy your public key onto your clipboard so you can paste it:

```shell
pbcopy < ~/.ssh/id_ed25519.pub
```

Note that your ssh public file will likely be named different. So you can `ls` in your `.ssh` directory to see the name so you can copy the file contents.

At this point, the above form should be filled out. Press the `Add SSH Key` button and then you you're ready to go! Now you can test that your SSH is working by cloning and pushing to a repo.

# Reference

If you had trouble with any of these steps, documentation on this process can be found in the following links. First go through the section [Generating a new SSH key](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#generating-a-new-ssh-key) and then [Adding a new SSH key to your account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account#adding-a-new-ssh-key-to-your-account).


Setting Up SSH Through Github

Since I've been reading Nietzsche, I've been further reflecting on my phone usage. I don't want my life to be revolved around others' impulses, have consistent interruprtions and be pulled from my thoughts and the immersion of life. I agree with much of what he says. It's incredibly practical for current times.

So far, I really like the intentionality with the record player. It's very nice actually. I haven't been listening to much music, but when I do, it's much more intentional and immersive. This is mainly because I'm not doing it as a side thing to something else. I guess I would say I'm a scarcitist (if that's even a word).

I generally believe that abundance with deeply personal things reduces the value of them. Well, the value we could derive when sharing these things with others. It's like the idea of staking a claim. If you are limited and have constraints, what's most impotant when you must choose.

On Spotify, we can choose it all. We don't have to commit to any one thing. The novelty is limitless. It's the same for much of content, such as social media platforms.

This isn't to say these things are not without good. They of course democratize certain things and give people capaibilites they would otherwise not have. But, this doesn't go without concern.

Too many disruptions & phone usage takes away from one's life in various ways. It can become not a tool, but our master. If used without intentional thought. Generally, I'm not sure unlimited novelty is good for us. It at least hasn't been good for me. This being the reason of my pessimism.

I've gone down countless media spirals, doom scrolled, had my reality consistently broken by the thoughts of others and when an app decides it wants to try and re-engage me. It has worked very well. Too well. It's been a constant battle for what role technology will have in my life. But without firm principles, it has always crept back in. Allowing myself to easily undermine me.

Not that it in itself is the problem. But, devices have been engineered for re-engagement and make it much more difficult to resist their hedonic grasp. We can of course have problems with other devices, but my record player isn't sending me notifications telling me to use it. That would just be weird. And now that I think of it, just down right creepy.

Throughout the years, I've met many engineers that are all too aware of the dangers that lie within various products & devices. Many of which I've found to: not use social media, turn off all notifications, turn their screen to grayscale, not have their phone on their body and so on. Some of these may seem like extremes, but these behaviors are not without their reasons.

I've even worked with someone who's worked on the Facebook newsfeed. He said after seeing how intelligent it is and how hard they work to keep you on the platform, he's never used it since. He also doesn't allow his kids to and advise those around him not to. This is someone who helped build it and doesn't trust his ability to fight against it.

I'll always come back to the fact that the distracted will remain distracted. No matter how. But, it's not a good idea to have devices that make it that much harder, demand from us our attention and pull us away from our thoughts and lives right in front of us.

If you can keep a healthy relationship with these things, I applaud you. But, I would also argue that what many see as healthy is truly not.

Staring at your phone with others you're supposed to be interracting with is not healthy. Getting inconsequential notifications when you're focused is not healthy. Becoming addicted to novelty, wasting time on unimportant information and always having others' thoughts pressed upon you is not healthy.

Really, it's best to take a step back and think about what you want your life to look like. Is it one stuck behind your phone, distracted, anxious and unimersed? Or is it one of calm, intentionality and immersion? I pick the latter and I hope you do too.


Using useImperativeHandle to Access Child Component Functionality