Tomorrow, I'll be starting at HashiCorp as a Web Engineer. I'm particularly excited about this, and here's why.

Looking back

In my past 2.5 years at Capsule, I started as a Frontend Engineer but quickly made my way into every part of the stack. I worked pretty diligently towards this — met all of my sprint commitments/deadlines and did a ton of coding outside of work — and was also very fortunate to have been granted opportunities to join different teams and work on a variety of projects (greenfield and existing) by my managers and directors.

After tackling various parts of the stack, I still felt like I had one particular area that had considerable room for growth — DevOps. I never gained significant traction here, and still can't confidently say that I'd know what to expect in a DevOps role, but naturally, that makes me the most curious about it.

Looking forward

HashiCorp, being a company that offers cloud infrastructure automation tools like Terraform and Vault, could not be a more fitting next step.

And though I won't actually be working directly on any of those tools, being in close proximity to folks who do own those tools will be a great experience.

I've previously used Terraform for work, but barely scratched the surface and I've known about Vault as it was being adopted at my previous job, but didn't get a chance to use it personally. As for all of HashiCorp's other offerings, I have a lot of learning to do!

HashiCorp repositories

Here's a fun mini-project of some Github organization data that I pulled from their V4 API to recreate the pinned repositories as seen on https://github.com/hashicorp.

The JSON data is fetched via an authenticated request inside getStaticProps and passed to the scope of next-mdx-remote/serialize.

Pinned

GraphQL Query

fragment repositoryFragment on Repository {
  id
  name
  description
  url
  primaryLanguage {
    name
    color
  }
  stargazerCount
  forkCount
}

query PinnedRepositories($login: String!) {
  organization(login: $login) {
    name
    pinnedItems(types: REPOSITORY, first: 6) {
      totalCount
      nodes {
        ...repositoryFragment
      }
    }
  }
}

Go do some homework

Looking at the above repos, 5/6 are written in Go so I took this as a sign that it would be a good time to start learning Go.

The first thing I googled was "go lambda function", and I learned that AWS has had an official Go lambda runtime since 2018. I guess I never noticed this.

So there were two paths I could take with this...

1. Extend existing TypeScript AWS CDK code, and write one Go lambda function
2. Start clean and simple, and write everything in Go — lambda function code and CDK code

...I chose the later because I also discovered, by chance, that the AWS CDK just announced Go support a few months ago, so I just decided, "Why not... I'll just YEET everything in Go."

❯ cdk version
1.119.0 (build 2921d64)

I never noticed that fsharp and go were language options.

❯ cdk init
Available templates:
* app: Template for a CDK Application
   └─ cdk init app --language=[csharp|fsharp|go|java|javascript|python|typescript]
* lib: Template for a CDK Construct Library
   └─ cdk init lib --language=typescript
* sample-app: Example CDK Application with some constructs
   └─ cdk init sample-app --language=[csharp|fsharp|java|javascript|python|typescript]

It's Go time 🤪!

❯ cdk init app --language go
Applying project template app for go
# Welcome to your CDK Go project!

This is a blank project for Go development with CDK.

**NOTICE**: Go support is still in Developer Preview. This implies that APIs may
change while we address early feedback from the community. We would love to hear
about your experience through GitHub issues.

## Useful commands

 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template
 * `go test`         run unit tests

Initializing a new git repository...
✅ All done!

Project

Here's a working repository of Go AWS CDK code to build and provision one basic Go lambda.

Here's what a barebones Go lambda function looks like.

package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-lambda-go/lambda"
)

type MyEvent struct {
	Name string `json:"name"`
}

func HandleRequest(ctx context.Context, event MyEvent) (string, error) {
	return fmt.Sprintf("Hello %s!", event.Name), nil
}

func main() {
	lambda.Start(HandleRequest)
}

Todos

...to further familiarize with Go syntax

• Go through the Golang tour
• Check out https://gobyexample.com/
• Make the Go lambda function do some CRUD operations on DynamoDB and/or other resources

More Todos

Aside from Go, there's a ton of other new (and old) things I want to check off.

• Gain deeper understanding of Next.js inner workings
• Figure out how serverless-nextjs works
  • consider refactoring this site to be deployed with it so that it can benefit from SSR instead of SSG, and be able to use other Next.js features like API routes, and Image
• Learn some more HCL
• Understand enough GCP and Azure to draw parallels to AWS
• Use the Terraform CLI
• Learn about Vault, Consul, Waypoint, etc.
• Figure out how CLI's like Terraform and Vault are created and how they function under the hood
• Committing more classic algorithms to memory

So much to learn...

So little time...

Special thanks to Kyle M. 🙇🏻‍♂️!