Xeoncross

// https://leetcode.com/problems/valid-sudoku/submissions/900490403/

func isValidSudoku(board [][]byte) bool {
    // 9 spaces is > 8 bits so we use 2 bytes (an int16)
    rowsMap := [9]int16{}
    colsMap := [9]int16{}
    gridMap := [9]int16{}

    for row:=0; row<9; row++ {
        for col:=0; col<9; col++ {

Xeoncross

package safehttp
// HttpGetRequest assumes the response fits in memory and you're not trying to
// decode a json payload which would be better using json.NewDecoder()
func HttpGetRequest(ctx context.Context, url string, timeout time.Duration, sizeLimit int64) ([]byte, error) {
	// Create a new HTTP client with a timeout
	client := http.Client{Timeout: timeout}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err

Xeoncross

package mergesort

import (
	"fmt"
	"testing"

	"golang.org/x/exp/constraints"
)

// based on https://github.com/TheAlgorithms/Go/blob/master/sort/mergesort.go

Xeoncross

# Using homebrew
brew install java

>>>
For the system Java wrappers to find this JDK, symlink it with
  sudo ln -sfn /usr/local/opt/openjdk/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk.jdk

openjdk is keg-only, which means it was not symlinked into /usr/local,
because macOS provides similar software and installing this software in
parallel can cause all kinds of trouble.

Xeoncross

package wikipediatitles

import (
	_ "embed"
	"sort"
	"strings"
	"unicode"
)

// https://dumps.wikimedia.org/enwiki/20220801/enwiki-20220801-all-titles-in-ns0.gz

Xeoncross

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

1. Clarify and agree on the scope of the system

• User cases (description of sequences of events that, taken together, lead to a system doing something useful)
  • Who is going to use it?
  • How are they going to use it?

Xeoncross

package main

import "fmt"

func BenchmarkMapIteration(b *testing.B) {

	size := 1000
	ranked := make(map[int]uint8, size)
	for i := 1; i < size; i++ {
		ranked[i] = uint8(i % 8)

Xeoncross

package main

import (
	"encoding/binary"
	"fmt"
)

func main() {
	// subtract 1 from each answer since we're counting zero also
	fmt.Printf("%d bits = %8b = %d\n", 2, byte(1<<2-1), 1<<2)

Xeoncross

package iiexperiments

import (
	"fmt"
	"testing"
)

// How much space will using a delta encoding save?

// If we assume we have 1 byte (0-255) to tell us how many bytes the delta is contained in, we can then only store the diff between the last and next int values. This difference is the "delta".

Xeoncross

Rate Limiting Redis with multiples of a time.Duration

In a distributed system, you want the API layer to be stateless. So the app can offload rate limiting to a redis instance. This way, you can use the INCR to both increment and return the number of requests a given IP/Client/API Key has made across any number of App / serverless instances.

However, what do you do if the limit isn't roundable to the current second/minute/hour/day? How does each instance agree which key to use? The answer is to modulo the previous and future keys to find the right one.

For example, 3 requests every 5 seconds is the desired limit. That means we can use -max-1:+max-1 as the range of values to scan to find the key we should use.

max := 5