DEV Community: Nelson Figueroa

I Created My First AI-assisted Pull Request and I Feel Like a Fraud

Nelson Figueroa — Mon, 23 Mar 2026 00:00:00 +0000

I created my first AI pull request for Chroma, which is the default syntax highlighter used in Hugo.

I used Claude Code for that PR. I didn’t learn anything. I felt like I was flinging slop over the wall to an open-source maintainer. I felt like a fraud and my impostor syndrome got worse.

But here’s the thing, I still contributed something of value. It’s something I have been wanting in hugo for a long time to syntax highlight ERB snippets in my posts. It was approved and merged by the maintainer (thanks for dealing with my slop, Alec).

It just feels odd. I know there are many people that are excited this new era of writing code. But to me this has sucked out all of the fun. I have never felt like a bigger fraud in this field. I’ve always thought that I’m privileged that I get to have fun at all in my line of work. As Ori Bernstein says: “using LLMs to write code is as fun as hiring a taskrabbit to solve my jigsaw puzzles”.

But then again, I know that realistically I would not have the mental capacity or skill to create a pull request like that without AI tooling. My brain is already fried from work on most days. I don’t think I would have been able to learn the codebase and get enough context to make that PR all by myself. It’s a lot. I just wanted some ERB syntax highlighting for my little blog.

Even at work I’ve used Claude Code and other AI tooling to deliver fixes and improvements that have real customer impact. But no matter how big the impact, I feel empty. I agree with Xe Iaso in the first sentence of their post: “Whenever I have Claude do something for me, I feel nothing about the results”.

Now that using AI is a normal expectation at work and how I’m evaluated in performance reviews, I suspect that this fraud feeling will only grow. The industry as a whole is incentivizing delivering code/features/fixes at a quick pace even if it’s all just slop.

I keep thinking a lot about how I perhaps tied my identity too much to my career. I’m not the greatest engineer, but I’ve always worked hard to deliver good work and learn as much as possible. I care a lot about understanding underlying systems as much as possible. I care about the craftsmanship of my code (to the best of my abilities). Unlike me, AI tools don’t care about any of these values.

At the end of the day, the shareholders care about delivering features, gaining customers, and making money. They don’t care how software is built.

I don’t know what to make of this.

Adding Headers to HTTP Requests in Go

Nelson Figueroa — Fri, 30 Jan 2026 00:00:00 +0000

Go has several ways of sending requests, including some convenient methods such as:

http.Get()
http.Head()
http.Post()
http.PostForm()

However, these don’t let you add headers to requests! If you need customization of the HTTP method or headers, you need to use http.NewRequest().

There are three parts to this:

Create a request using http.NewRequest() where you specify the HTTP method and URL
Add headers to the request with Header.Set()
Send the request using http.Client{}

Here’s a full example:

package main

import (
    "net/http"
)

func main() {
    // create the client that will send the request later
    client := &http.Client{}

    // create a request with NewRequest, specifying HTTP method and URL
    req, err := http.NewRequest("GET", "https://example.com/", nil)
    if err != nil {
        // handle any errors however you'd like
    }

    // add headers to the request
    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0")
    req.Header.Set("Accept-Language", "en-US,en;q=0.9")
    req.Header.Set("Accept-Encoding", "gzip, deflate")
    req.Header.Set("Sec-GPC", "1")
    req.Header.Set("Connection", "keep-alive")

    // use the client to actually send the request
    resp, err := client.Do(req)
    if err != nil {
        // handle any errors however you'd like
    }
    defer resp.Body.Close()
}

Note:

req.Header.Set() can be used to set a header but will _ overwrite _ any existing value for that header.

req.Header.Add() can be used to add a value to a header and will append to any existing value for that header.

For the purposes of this blog post we only need to worry about setting the header once, hence the usage of req.Header.Set().

Similar to my “Using time.Sleep() in Go” post, I wrote this up because the Go docs are too dense and I just needed one full example to understand it and get going.

References

https://pkg.go.dev/net/http

Using time.Sleep() in Go

Nelson Figueroa — Thu, 29 Jan 2026 00:00:00 +0000

Basic Usage of `time.Sleep()`

You can use time.Sleep() to pause your program for a predetermined amount of time, similar to most programming languages.

First, you should know that the time package has useful constants that allow you to conveniently specify time in units.

const (
    Nanosecond Duration = 1
    Microsecond = 1000 * Nanosecond
    Millisecond = 1000 * Microsecond
    Second = 1000 * Millisecond
    Minute = 60 * Second
    Hour = 60 * Minute
)

They’re accessed with the time.<Constant> notation. (e.g. time.Second)

You can use these constants with the time.Sleep() function. For example, if we want to pause execution for 1 second, we can write the following code:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("one second will pass between this message...")
    time.Sleep(time.Second)
    fmt.Println("...and this message")
}

We can do some multiplication with time.Second to pause a program for 30 seconds:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("30 seconds will pass between this message...")
    time.Sleep(time.Second * 30)
    fmt.Println("...and this message")
}

You can do multiplication with all of the other constants mentioned as well.

Examples

Here are some more examples using the other constants.

Sleep for 500 milliseconds

package main

import (
    "time"
)

func main() {
    time.Sleep(time.Millisecond * 500)
}

Sleep for 10 seconds

package main

import (
    "time"
)

func main() {
    time.Sleep(time.Second * 10)
}

Sleep for 5 minutes

package main

import (
    "time"
)

func main() {
    time.Sleep(time.Minute * 5)
}

Sleep for 2 hours

Not really sure why you would use this, but just know it’s possible.

package main

import (
    "time"
)

func main() {
    time.Sleep(time.Hour * 2)
}

References

https://pkg.go.dev/time

My main motivation for writing this is that I think the official documentation is way too dense and doesn’t show several examples of time.Sleep(). I just needed some examples to understand the syntax and move on with my day.

What I Actually Want To Say in Tech Interviews

Nelson Figueroa — Mon, 29 Dec 2025 00:00:00 +0000

> “Why do you want to work for our company?”

Your company has an opening that I believe I am qualified for that also pays more than my current position. I also need money to pay for bills, groceries, rent, and the overall cost of being alive.

> “Why are you leaving your current company?”

I found a job opening at your company that pays more than my current role.

> “What are you looking for in the next role?”

A big pay bump. Opportunities to become better at software engineering would be cool too.

> “What excites you about this role?”

Two things:

This position at your company pays more than my current role.
There may be more opportunities to grow as a software engineer. But mostly the first reason.

> “What are your salary expectations?”

Whatever the maximum of the salary range is for this position.

> “Where do you see yourself in 5 years?”

If the compensation for this position increases year to year and is in line with other top paying companies, I see myself staying at your company. It also helps if there are growth opportunities for me as a software engineer.

Otherwise, I see myself at a different company from yours that pays more.

On a more serious note…

Don’t get me wrong, growing as a software engineer is still important to me. I want to work with great people and build cool things. It just sucks that I have to lie during interviews because honesty would get me disqualified. Doing 4+ rounds of interviews is already exhausting enough.

GitHub Actions for Pulumi with an AWS S3 Backend

Nelson Figueroa — Thu, 11 Dec 2025 00:00:00 +0000

Introduction

This is a quick guide to set up GitHub Actions for Pulumi with an AWS S3 Backend. There are some differences compared to running pulumi commands locally. This guide assumes you have the following:

An AWS S3 Bucket created and ready to be used with Pulumi
An IAM User that has permissions to read/write to the S3 bucket
The Access Key and Secret Access Key for the IAM User to use for authenticating to AWS within GitHub Actions
A passphrase of your choosing that will be used to encrypt secrets in the pulumi stack
A GitHub repository

Setting up Repository Secrets

First, set up secrets on your GitHub repository. These will be filled in by GitHub Actions once we create a workflow YAML. You’ll need to create 3 secrets. You can name them whatever you want, but I’ll be naming them:

AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
PULUMI_CONFIG_PASSPHRASE

You can create these by browsing to your GitHub repository > Settings > Secrets and variables > Actions. There are “Environment secrets” and “Repository secrets”. In this case go with “Repository secrets”.

Create the three secrets and fill in their respective values. PULUMI_CONFIG_PASSPHRASE can be whatever you want and doesn’t come from AWS. Make sure you don’t change this after the fact though, or your Pulumi state may break. The end result should look like this:

Defining the GitHub Actions Workflow

Next, clone the repository locally with git clone. We’ll need to create a few files for a minimum viable Pulumi program. Run pulumi new and it’ll guide you through the creation of a basic Pulumi program. The language you choose doesn’t matter.

Then we can create the YAML file to set up GitHub Actions. Create a YAML file under <your-repository-name>/.github/workflows/. I’ll call it preview.yml in my example. Fill it in with the following YAML, changing values as needed.

name: Pulumi
on:
  push:
    branches:
      - main # change this if you're using a different branch name

jobs:
  preview:
    name: Preview
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Pulumi Preview
        uses: pulumi/actions@v6.6.1
        with:
          command: preview
          stack-name: dev # change this to your stack's name (or whatever you want it to be if it doesn't exist)
          cloud-url: s3://nelson-test-bucket-for-github-actions # change this to your bucket name to be used as a pulumi backend
          upsert: true # creates a stack if it doesn't exist (along with Pulumi.<stack>.yaml)
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          PULUMI_CONFIG_PASSPHRASE: ${{ secrets.PULUMI_CONFIG_PASSPHRASE }}
          AWS_REGION: us-east-1 # change the region as needed

This runs a pulumi preview so it’ll veryify that everything is set up correctly without actually deplpoying anything.

Testing the Workflow

Now push your code to GitHub and see if the GitHub Action workflow ran successfully. You should see output from a successful pulumi preview.

If this works, you should be good to go. You can update your Pulumi code and, change command: preview to command: up in the GitHub Actions YAML file and run it again to actually deploy some infrastructure.

References

https://github.com/pulumi/actions

How to Actually Copy a List in Python

Nelson Figueroa — Fri, 14 Nov 2025 00:00:00 +0000

tl;dr: use the copy() method.

Say we have two Python lists – list_a and list_b.

If we try to make a copy of list_a and assign it to list_b using the assignment operator =, what really happens is that both list_a and list_b point to the same memory address.

That means that any list-manipulating actions that are done on either list_a or list_b will affect the same list in memory. We don’t have actually have two separate lists we can act upon.

In the example below, although we append the integer 4 to list_a, we can see that printing out list_b shows the newly added element. That’s because both list variables point to the same memory address:

list_a = [1, 2, 3]
list_b = []

list_b = list_a

print(list_b) # [1, 2, 3]

list_a.append(4)

print(list_b) # [1, 2, 3, 4]

Output of the program above:

[1, 2, 3]
[1, 2, 3, 4]

To make an actual copy, use the copy() method. Then, when list_a is modified, it is independent of list_b, because list_b is stored in a separate memory address.

Now if we append the same integer 4 to list_a, list_b will be completely unaffected.

list_a = [1, 2, 3]
list_b = []

list_b = list_a.copy() # using copy()

print(list_b) # [1, 2, 3]

list_a.append(4)

print(list_a) # [1, 2, 3, 4]
print(list_b) # [1, 2, 3]

Output of the program above:

[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3]

Here’s more proof. We can print out the memory address of each variable to see when they’re the same and when they differ. We can do this using the id() function.

Here are the same lists from above but this time with their unique identifiers printed out. In this case, the IDs match because both list_a and list_b point to the same memory address.

list_a = [1, 2, 3]
list_b = []

list_b = list_a

print(f'list_a address: {id(list_a)}')
print(f'list_b address: {id(list_b)}')

The program above outputs:

list_a address: 140226819497536
list_b address: 140226819497536

The memory addresses are the same.

Now let’s try the same thing but using the copy() method instead of just an assignment operation with =:

list_a = [1, 2, 3]
list_b = []

list_b = list_a.copy()

print(f'list_a address: {id(list_a)}')
print(f'list_b address: {id(list_b)}')

The program above outputs:

list_a address: 140264515620480
list_b address: 140264514892160

We can see the memory addresses are different (most obvious due to the ending digits).

Although I’ve been in the field for some time, I still have my smooth brain moments. This is a reminder to myself (and whoever reads this) to remember the basics!

References

Creating High Quality GIFs from Asciinema Recordings

Nelson Figueroa — Sat, 04 Oct 2025 00:00:00 +0000

Say you have a recording created with Asciinema named recording.cast and now you want to convert that into a GIF. You can use the agg command (which is a separate installation to convert it like so:

agg recording.cast recording.gif

However, if you run agg with the default settings the resulting GIF won’t be high quality and it’ll look a little fuzzy.

To get a high quality GIF you need to specify a big font size with the --font-size option:

agg --font-size 64 recording.cast recording.gif

Here are two GIFs you can compare. The top one was created with the default agg settings. The bottom one was created with --font-size 64. Depending on your display, you may need to zoom in a bit to see the difference.

(Note: dev.to compresses gifs, you may need to do the comparison on the original link: https://nelson.cloud/creating-high-quality-gifs-from-asciinema-recordings/)

It’s a noticeable difference. The trade-off here is that the higher quality GIF will be a bigger filesize, so be mindful of that. Try experimenting with different font sizes.

I was expecting there to be some sort of --size or --quality option, but you just need to increase the font to get higher quality GIFs with agg.

References

Quick Tip: Mute the Terminal Login Message with A .hushlogin File

Nelson Figueroa — Sun, 28 Sep 2025 00:00:00 +0000

Today I learned that you can create an empty .hushlogin file in your home directory on macOS and Linux to hide the login message you get when starting up a new terminal window or tab.

I tried this on macOS but it should work on Linux too.

For example, when I start up a new terminal window/tab I see the following message:

After I create the .hushlogin file in my home directory, the login message goes away. First I created the file:

touch ~/.hushlogin

Then I opened a new terminal window to verify that the message no longer shows up:

References:

How to Use an AWS S3 Bucket as a Pulumi State Backend

Nelson Figueroa — Sat, 20 Sep 2025 00:00:00 +0000

I’ll be starting from scratch and creating an IAM user with access to an S3 bucket that will be used to store the Pulumi state file. If you’re working in an enterprise setting, your authentication methods may vary.

The TL;DR is that you can run this if you already have an S3 bucket and AWS credentials configured on your machine:
pulumi login 's3://<bucket-name>?region=<region>&awssdk=v2&profile=<aws-profile-name>'

This post assumes you have the Pulumi CLI installed. Check out the following guide if you don’t have it installed: Download & install Pulumi.

Creating an S3 Bucket

First, we need to create the S3 bucket where the Pulumi state file will be stored. I created a bucket called nelsons-pulumi-state-backend and left all the default settings as-is.

Creating an IAM User

Then we need to create an IAM user in AWS that the Pulumi CLI can use. This IAM user needs permissions to access the S3 bucket we just created.

I go to IAM and create a new user. I just called it pulumi:

Then in the next step, I selected "Attach policies directly" and selected the AWS-managed “AdministratorAccess” policy just to keep things simple. You can provide more fine-grained access depending on your needs. Then click “Next” at the bottom.

In the next screen, double check everything and then click on “Create user”.

Now that we have a user with the appropriate permissions, we’ll need to get an AWS access key and secret to use with the Pulumi CLI.

Go to your IAM user and click on "Create access key" on the right side.

In the next screen, select “Command Line Interface (CLI)”. Check the box at the bottom, then click “Next”.

The next screen will ask for setting a description tag. This is optional. I chose to skip it and clicked on “Create access key”.

We finally have our Access key and Secret access key. Save these somewhere safe and click “Done”. (Don’t worry, the credentials in the screenshot are fake.)

Setting Up AWS Credentials for the Pulumi CLI

Now we can try using these credentials to tell the Pulumi CLI to use the S3 bucket as a backend.

Note that you do NOT need the AWS CLI installed. Pulumi just needs the AWS credentials.

Create the file ~/.aws/credentials if you don’t have it. Then add in your credentials there under the [default] profile. (You can add more profiles, but this is beyond the scope of this post.)

[default]
aws_access_key_id = <key_id>
aws_secret_access_key = <access_key>

You’ll need the bucket’s region and your local AWS profile name to use S3 as a backend.

The command formula looks like this:

pulumi login 's3://<bucket-name>?region=<region>&awssdk=v2&profile=<aws-profile-name>'

In my case, the command looks like this (make sure to edit for your needs):

pulumi login 's3://nelsons-pulumi-state-backend?region=us-west-1&awssdk=v2&profile=default'

A successful login shows the following message:

Logged in to 0x6E.local as nelson (s3://nelsons-pulumi-state-backend?region=us-west-1&awssdk=v2&profile=default)

Alternatively, you can add your backend to your Pulumi.yaml file. This is useful if you're working on multiple Pulumi projects that each have different backends. You won't need to run pulumi login all the time. Just add a backend key and a nested url key:

name: my-pulumi-project
description: a pulumi project for testing
runtime: nodejs

# add this section
backend:
  url: s3://nelsons-pulumi-state-backend?region=us-west-1&awssdk=v2&profile=default

More information here: Pulumi project file reference.

Testing The Setup

Finally, it’s time to test this out.

To demonstrate, I created a simple Pulumi program by running:

pulumi new aws-python

You can choose whatever language you want though.

This is the main Pulumi code that is generated. It’s code for creating an S3 bucket:

"""An AWS Python Pulumi program"""

import pulumi
from pulumi_aws import s3

# Create an AWS resource (S3 Bucket)
bucket = s3.Bucket('my-bucket')

# Export the name of the bucket
pulumi.export('bucket_name', bucket.id)

Then I ran pulumi up -y and it worked!

And just to double check, I can see that my previously empty S3 bucket now has contents created by the Pulumi CLI:

References

It’s 2025, Why Aren’t You Using an Ad Blocker?

Nelson Figueroa — Mon, 02 Jun 2025 00:00:00 +0000

I find myself asking this any time I discover that someone uses a web browser with no ad blocking solution. More specifically, it blows my mind when tech-savvy people that work in software development (and related roles) don’t use ad blockers. I don’t understand why.

The “main” web is a terrible experience when browsing without ad blockers.

If you’re one of those people that doesn’t have an ad blocker here are some links to improve your web browsing experience.

Browser Extensions to Block Ads

The best and arguably only ad blocker you’ll need for your browser is uBlock Origin. It has worked consistently for me on Firefox and Chrome for many, many years.

Here are some convenient links to get uBlock Origin:

Get the uBlock Origin Firefox extension
Get the uBlock Origin Chrome extension
Get the uBlock Origin Microsoft Edge extension (if you use Edge for some reason)

For Safari Users

Safari doesn’t support extensions like other browsers. While there is some tracking protection out of the box it doesn’t compare to uBlock Origin. If you REALLY want to keep using Safari then check out AdGuard for Mac. It blocks ads system-wide on macOS and not just in Safari.

If you like the Safari aesthetic but don’t want to install AdGuard, check out Orion Browser. It comes with ad blocking out of the box. It’s based on WebKit just like Safari. There’s even an iOS app available.

Brave Browser

Brave Browser is also a great browser if you want an ad-free web experience. It’s available on all major platforms (Windows, Android, Linux, macOS, iOS) and it comes with ad blocking built in. I hesitate a bit to recommend Brave because it comes with some optional crypto BS called Basic Attention Token, but you don’t have to opt into that.

Get Brave Browser

Start Browsing the Web with Ad Blockers

There are many options for blocking ads regardless of the device you’re using. Start browsing the web with an ad blocker and you’ll never go back to browsing the normal ad-infested web.

Validate HTTP Status Codes in Go Using Built-in Constants

Nelson Figueroa — Sat, 24 May 2025 00:00:00 +0000

Constants to Use When Checking for HTTP Status Codes

Go has useful constants in the net/http package that can make your code more readable when checking for status codes in responses.

For example, instead of writing something like

if resp.StatusCode == 200 {
    // do something if the status code is 200
}

You can write

if resp.StatusCode == http.StatusOK {
    // do something if the status code is 200
}

Unfortunately the the link doesn’t show any any full, working examples. So here’s an example covering some of the more common http status codes that you can use and modify as needed.

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    resp, err := http.Get("https://example.com")
    if err != nil {
        log.Fatalf("error: %v", err)
    }

    defer resp.Body.Close()

    // Status code 200
    if resp.StatusCode == http.StatusOK {
        fmt.Println("ok!")
    }

    // Status code 301
    if resp.StatusCode == http.StatusMovedPermanently {
        fmt.Println("moved permanently")
    }

    // Status code 403
    if resp.StatusCode == http.StatusForbidden {
        fmt.Println("forbidden")
    }

    // Status code 404
    if resp.StatusCode == http.StatusNotFound {
        fmt.Println("not found")
    }

    // Status code 429
    if resp.StatusCode == http.StatusTooManyRequests {
        fmt.Println("too many requests")
    }

    // Status code 500
    if resp.StatusCode == http.StatusInternalServerError {
        fmt.Println("internal server error")
    }

    // Status code 502
    if resp.StatusCode == http.StatusBadGateway {
        fmt.Println("bad gateway")
    }
}

Turning Http Status Codes into Messsages with `Statustext()`

There’s also a function http.StatusText() that allows you to pass in status codes and get a message for logging purposes or displaying to users. You can see all the responses in the source code here, it’s a bunch of case statements.

For example, lets say we want to display a message if we don’t get a 200 status code. Instead of writing code to print out a different message depending on the status code value, we can use the http.StatusText() function:

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    resp, err := http.Get("https://example.com/404") // this URL returns a 404 status code
    if err != nil {
        log.Fatalf("error: %v", err)
    }

    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        // if it's not 200, print out a message depending on the status code
        fmt.Println(http.StatusText(resp.StatusCode)) // http.StatusText() is called here
    }
}

$ go run example.go

Not Found

Super convenient.

References

How to Clone a Specific Git Branch Without Other Branches

Nelson Figueroa — Thu, 27 Feb 2025 00:00:00 +0000

Cloning a Specific Branch

To clone a specific branch of a git repository without cloning all other branches, use the following command formula:

git clone --single-branch --branch <branch_name> <repo_URL.git>

For example, if you want to clone the release-1.28 branch of the Kubernetes GitHub repository, run:

git clone --single-branch --branch release-1.28 https://github.com/kubernetes/kubernetes.git

Cloning the Latest Commit of a Specific Branch

If you only want to clone the latest commit of a specific branch (which results in a faster and smaller cloning operation) use --depth 1. The command formula looks like this:

git clone --single-branch --branch <branch_name> --depth 1 <repo_URL.git>

And here is another example using the release-1.28 branch of the Kubernetes GitHub repository:

git clone --single-branch --branch release-1.28 --depth 1 https://github.com/kubernetes/kubernetes.git

DEV Community: Nelson Figueroa

I Created My First AI-assisted Pull Request and I Feel Like a Fraud

Adding Headers to HTTP Requests in Go

References

Using time.Sleep() in Go

Basic Usage of time.Sleep()

Examples

Sleep for 500 milliseconds

Sleep for 10 seconds

Sleep for 5 minutes

Sleep for 2 hours

References

What I Actually Want To Say in Tech Interviews

GitHub Actions for Pulumi with an AWS S3 Backend

Introduction

Setting up Repository Secrets

Defining the GitHub Actions Workflow

Testing the Workflow

References

How to Actually Copy a List in Python

References

Creating High Quality GIFs from Asciinema Recordings

References

Quick Tip: Mute the Terminal Login Message with A .hushlogin File

References:

How to Use an AWS S3 Bucket as a Pulumi State Backend

Creating an S3 Bucket

Creating an IAM User

Setting Up AWS Credentials for the Pulumi CLI

Testing The Setup

References

It’s 2025, Why Aren’t You Using an Ad Blocker?

Browser Extensions to Block Ads

For Safari Users

Brave Browser

Start Browsing the Web with Ad Blockers

Validate HTTP Status Codes in Go Using Built-in Constants

Constants to Use When Checking for HTTP Status Codes

Turning Http Status Codes into Messsages with Statustext()

References

How to Clone a Specific Git Branch Without Other Branches

Cloning a Specific Branch

Cloning the Latest Commit of a Specific Branch

References

Basic Usage of `time.Sleep()`

Turning Http Status Codes into Messsages with `Statustext()`