Mark McDonnell Integralist

https://pkg.go.dev/tailscale.com/util/ctxkey

Example Playground: https://play.golang.com/p/aZ0joNec3Xl

package main

import (
	"context"
	"fmt"

DNS Management and Delegation

If a domain owner wants to use another company for handling DNS management over its domain, then they can update the "Name Servers" for their domain wherever DNS is currently managed, and set the Name Servers to a different DNS provider.

This is known as DNS delegation.

Once that Name Server change has propagated, the new DNS provider will be responsible for managing DNS records for the domain.

CNAME redirection magic

.
├── Makefile
├── cmd
│   └── api
│       └── main.go
├── go.mod
├── go.sum
├── internal
│   ├── api

Outcome

Implementation

# digg adds colors to the standard dig output to improve readability while not losing contextual information.
#
DIG_COMMENT_COLOR_SINGLE="\e[38;5;8m"  # Dark grey text, no background, no bold

.well-known is a standardized path on a website's root domain that allows services to access metadata and configurations related to that domain. It's defined by RFC 5785.

The IANA (Internet Assigned Numbers Authority) maintains a registry of well-known URIs, ensuring that these paths are standardized and avoid conflicts.

What's a ring buffer?

Ring buffers are known by a few names, such as circular queues and circular buffers.

A ring buffer is a fixed-size, circular data structure that overwrites the oldest data when the buffer is full. It’s particularly useful for scenarios where you want to store and retrieve data in a FIFO (First-In-First-Out) manner but with limited memory. When the buffer reaches its size limit, new data will overwrite the oldest data.

Instead of adding on the end and popping from the end, like a stack, you can add to one end and remove from the start, like a queue. And as you add or remove things, the start and end pointers move around. By managing these pointers, a ring buffer naturally enforces the FIFO order.

What's the benefit?

There are three types of documents you should write, in this specific order:

Project document
Discovery document
Design document

A "project" document is for planning the overarching/broader project work.
It's responsible for breaking down the project into smaller milestones.

A "discovery" document is for discovering how we'll solve ONE of the milestones defined in the project document.

	// Package gob manages streams of gobs - binary values exchanged between an Encoder
	// (transmitter) and a Decoder (receiver).
	package main

	import (
	"bytes"
	"encoding/gob"
	"fmt"
	"log"
	)

	# install dependencies
	brew install graphviz plantuml librsvg

	# generate puml file for entire project
	go run github.com/jfeliu007/goplantuml/cmd/goplantuml@latest -recursive ./ > Example.puml

	# generate SVG from entire project
	plantuml Example.puml -o "$pwd" -tsvg

	# convert SVG into a PDF