James Simas

Finding the single number with XOR

Tue, 24 Feb 2026 16:18:22 -0800

I’ve been drilling on LeetCode recently and ran into a problem which I did not know how to solve while using constant extra space:

Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

You must implement a solution with a linear runtime complexity and use only constant extra space.

Example 1:

Input: nums = [2,2,1]

Output: 1

Example 2:

Input: nums = [4,1,2,1,2]

Output: 4

Example 3:

SQL Common Table Expressions

Thu, 18 Dec 2025 15:19:03 -0800

Today I spent some time learning about SQL common table expressions (aka “CTEs”). I already use subqueries, so they were easy to understand.

The syntax is very simple:

WITH my_cte AS (
 SELECT col1, col2, col3
 FROM table1
)
SELECT col1, col3
FROM my_cte
WHERE ...

Here’s a more complex example with two CTEs:

WITH my_cte1 AS (
 SELECT col1, col2, col3
 FROM table1
),
my_cte2 AS (
 SELECT col4, col5, col6
 FROM table1
)
SELECT my_table.*, my_cte1.col1, my_cte2.col4
FROM my_table
 JOIN my_cte1 ON my_table.fkey_id1 = my_cte1.col1
 JOIN my_cte2 ON my_table.fkey_id4 = my_cte1.col4
WHERE ...

In general, I should prefer CTEs over subqueries because:

BASH Process Substitution

Tue, 16 Dec 2025 20:25:05 -0800

Today, I learned about shell process substitution from Break on Penguin’s latest video.

Assume you have two files:

$ cat file1
a
b
c
$ cat file2
c
b
a

To see if they are identical when sorted without manually creating your own temporary files, you can:

diff <(sort file1) <(sort file2)

What is happening here?

<() is doing process substitution, which is running the command and then exposing its output as a temporary file.

Sublime Text Arithmetic Command

Wed, 19 Nov 2025 20:08:52 -0800

I’ve been using Sublime Text as my main text editor since August of 2014. I know it pretty well, but occassionally I still learn something new and useful.

Today I learned about the Arithmetic command from a video by OdatNurd.

Summary of what I learned

Variables

The following variables are supported:

Variable	What it does
`s`	The literal selected text
`i`	The selected text interpreted as a number (`0`, if interpretation fails)
`i`	The index of each selection (0-indexed)

Converstions

hex(x) // to hex
int(x) // to decimal
bin(x) // to binary

format() is supported

format(x, ',') // add comma separators to number, 1234 -> 1,234
format(x, '^80') // center selected text in 80-character column

math package is supported

math.ceil(x)
math.floor(x)

TIP: update numbers of an ordered list

This is particularly useful; I do this all the time!

SSH Key Best Practices

Wed, 10 Sep 2025 21:41:10 -0700

Today I needed to create a new SSH public/private keypair for work. I wanted to make sure I was following modern best practices for this, so I did some reading online.

I found these two articles to be very helpful:

Things I learned

I didn’t ever think to change the comment at the end of the keyfile. Now I plan to date them, as it suggests. Using the email sub-alias (+) is clever and I’m stealing that.

Treating strings as numbers in Golang

Thu, 28 Aug 2025 18:50:28 -0700

Today I encountered an API which sometimes sends back numbers as strings.

Example response:

{
 "age": "30"
}

That’s annoying, because I wanted my struct in Go to be like this:

type Person struct {
 Age int `json:"age"`
}

I learned that json struct tags have a string option meant for dealing with exactly this sort of problem:

The “string” option signals that a field is stored as JSON inside a JSON-encoded string. It applies only to fields of string, floating point, integer, or boolean types. This extra level of encoding is sometimes used when communicating with JavaScript programs:

Even Easier Git Rebasing

Thu, 28 Aug 2025 17:50:28 -0700

Rebasing your feature branch on main regularly is a good idea.

I used to do it like this:

# update local copy of main
git fetch origin main:main

# rebase on local main
git rebase main

This always felt a litle off because I was worried I’d typo main:main and mess it up.

This works just as well and feels much better to me:

# update local copy of `origin/main`
git fetch

# rebase on origin/main
git rebase origin/main

How to add values to an HTTP query string in Go

Tue, 26 Aug 2025 18:58:08 -0700

Here’s how to add key/value pairs to an http.Reqest’s query string in Go:

package main

import (
 "fmt"
 "net/http"
)

func main() {
 // create a request
 req, _ := http.NewRequest(http.MethodGet, "http://www.example.com/", nil)

 // get the current query string from the http.Request
 values := req.URL.Query()

 // add or set values
 values.Set("myKey1", "myVal1") // overwrite!
 values.Add("myKey1", "myVal2") // append!

 // add values back to the request
 req.URL.RawQuery = values.Encode() // query string: mykey1=myVal1&myKey1=myVal2

 // print the url
 fmt.Println(req.URL.String())
}

The above program will output:

Binaries on Macos

Fri, 22 Aug 2025 09:07:47 -0700

Path	Note
`/usr/local/bin/`	System-wide binaries go here!
`~/bin/`	My user’s binaries go here!

Initial thoughts on Ghostty

Mon, 18 Aug 2025 19:34:22 -0700

I’ve been using Alacritty exclusively for over a year. It’s fantastic!

But I listened to an interview with Mitchell Hashimoto and he talked about trying to make terminal multiplexers obsolete. It struck a cord with me. I’ve been using Zellij ever since I switched from Iterm2 to Alacritty and it’s great, but also it can be cumbersome.

I find it cumbersome to:

Search through this history (I don’t do it frequently enough for the keybindings to stick in my head.)
Splitting and closing panes. (Whereas iTerm2’s keybindings to do this are burned into my brain forever.)

For all iTerm2’s faults, I miss it sometimes. (The biggest reason I ditched it is because you can’t commit its config to version control easily. Its config is huuuuuuge. And I won’t daily drive anything whose config I can’t version.)

Using Github Issues

Thu, 10 Jul 2025 17:29:30 -0700

This interview with Simon Willison is great.

It pushed¹ me into using GitHub Issues for my private repositories. They’re wonderful. (In the past, I’ve been just tracking everything in Markdown documents. That worked, but was just OK.)

As an example, I have a private GitHub repo with notes and documents for a private network I maintain (as a volunteer). It’s very ad-hoc and I sometimes go months between without working on it.

HTTP/1, HTTP/2, and HTTP/3

Wed, 09 Jul 2025 20:09:59 -0700

There have been four¹ major versions of HTTP in-use in the last 30-ish years:

Version	RFC	Year
HTTP/1.0	RFC 1945	1996
HTTP/1.1	RFC 2068	1997
HTTP/2	RFC 7540	2015
HTTP/3	RFC 9114	2022

It’s surprising to me how quickly HTTP/1.1 was released after HTTP/1.0. Less than one year!

HTTP/1.0

A simple, text-based protocol.
Runs over TCP.
Only officially supports a single HTTP request and response over each TCP connection, then the connection was torn down.

HTTP/1.1

Still a text-based protocol.
Added connection re-use.
- On by default.
- Controlled via the Connection: keep-alive header and tuned via Keep-Alive.
Added the Host header, which allows multiple websites to be hosted at a single IP address.
Better cache control mechanisms.
Added HTTP pipelining (allowing multiple requests to be sent in succession before responses were received). Apparently never got widespread support, though.
Still suffers from Head of Line blocking.
- Even though TCP connections get re-used, a given request/response cycle must complete before the connection is eligible for re-use.
Many browsers improved throughput by allowing up to 6 TCP connections per domain. Websites took this even further with domain sharding.
- Example: Sharding resources over www1.foo.bar, www2.foo.bar, www3.foo.bar gives you 18 connections to play with.
No compression of headers. Lots of redundant data sent for each request/response in the headers, which is inefficient.

HTTP/2

Based on pioneering work done by Google with their SPDY (pronounced: “speedy”) protocol in the 2010s.
No longer a text-based protocol; now a binary-based protocol.
Allows request multiplexing over a single TCP connection.
Solved the application-layer Head of Line Blocking problem, but did not solve it for the transport layer (e.g., a dropped TCP packet would still delay all requests/responses behind it).
Adds header compression.

HTTP/3

Still a binary-based protocol.
Moved from TCP to UDP+QUIC for the transport layer. Many improvements come from this.
- Faster connection setup
  - Old: Setting up a TLS connection with older protocols required around three round trips (3-RTT): the TCP handshake (around 1-RTT) and TLS handshake (2-RTT).
  - New: Setting up a TLS connection with QUIC requires a single round trip (1-RTT) because the transport connection setup and TLS handshakes are merged. Note that 0-RTT resumption is possible with QUIC as well.
- Avoids the transport-layer head of line blocking problem by using multiple streams. Head of line blocking now fixed at both HTTP and transport layer.
Faster connection migration via Connection IDs. (Allows a client to switch networks seamlessly while browsing.)

Closing

It was interesting going down this rabbit hole on HTTP.

System Design Patterns by Sean Goedecke

Wed, 02 Jul 2025 17:03:28 -0700

This blog post by Sean Goedecke was a great read on high-level system design patterns.

Most of them were familiar to me, but I got several good ideas from it.

Using a database as queue:

Sometimes you want to roll your own queue system. For instance, if you want to enqueue a job to run in a month, you probably shouldn’t put an item on the Redis queue. Redis persistence is typically not guaranteed over that period of time (and even if it is, you likely want to be able to query for those far-future enqueued jobs in a way that would be tricky with the Redis job queue). In this case, I typically create a database table for the pending operation with columns for each param plus a scheduled_at column. I then use a daily job to check for these items with scheduled_at <= today, and either delete them or mark them as complete once the job has finished.

Tools to Organize Your Life

Wed, 25 Jun 2025 14:22:39 -0700

Much productivity advice on the internet is too complicated and not actually that helpful.

Complicated systems are less likely to be used due to the friction of using them and are more brittle in the face of changing needs. You are better off use basic, flexible systems; you are more likely to use simple systems and simple systems can adapt to change more easily.

There are only a few tools you need to completely run your personal life. They are:

Keep Email Useful

Thu, 19 Jun 2025 09:40:27 -0600

I get the impression that a lot of people are overwhelmed by their personal email inbox nowadays and get so much email that they’ve more or less given up on it.

I don’t have that problem and that’s by design, not by accident. This post explains the rules I use to keep my personal email useful and very manageable.

Unsubscribe aggressively

Any time you give your email address out nowadays, you will get put on a mailing list.

Echo Router Parameters

Fri, 06 Jun 2025 15:21:38 -0700

I regularly have to look up how to create an Echo router context with (a) path parameters and (b) query parameters, so I’m making this post as a cheat sheet for my future self.

Path parameters

Example: /some/random/path/:id

// create your context
ctx := echo.New().NewContext(request, response)

// add your path param
ctx.SetParamNames("id")
ctx.SetParamValues("foo")

Query parameters

Example: /some/random/path?key1=value1&key2=value2

// create your request
request := httptest.NewRequest(http.MethodPost, "/some/random/path", nil)

// get existing query params
query := request.URL.Query()

// add or set new params
query.Add("key1", "value1")
query.Set("key2", "value2")

// encode the query params back to the request
request.URL.RawQuery = query.Encode()

// create your context with the request
ctx := echo.New().NewContext(request, response)

Go Backoff Algorithms

Wed, 04 Jun 2025 10:07:18 -0700

I ran across a blog post by Josh Bleecher Snyder today which has some beautiful backoff algorithms in Go.

Capturing them here in case his blog ever goes offline.

Algorithm 1

func do(ctx context.Context) error {
 const (
 maxAttempts = 10
 baseDelay = 1 * time.Second
 maxDelay = 60 * time.Second
 )

 delay := baseDelay
 for attempt := range maxAttempts {
 err := request(ctx)
 if err == nil {
 return nil
 }

 delay *= 2
 delay = min(delay, maxDelay)

 jitter := multiplyDuration(delay, rand.Float64()*0.5-0.25) // ±25%
 sleepTime := delay + jitter

 select {
 case <-ctx.Done():
 return ctx.Err()
 case <-time.After(sleepTime):
 }
 }

 return fmt.Errorf("failed after %d attempts", maxAttempts)
}

func multiplyDuration(d time.Duration, mul float64) time.Duration {
 return time.Duration(float64(d) * mul)
}

Algorithm 2

I really like this one. It’s very easy to read.

How to view and remove routes on macOS

Fri, 30 May 2025 13:29:54 -0700

Today I needed to remove a bad route on macOS. Normally I just reboot to do that, but I decided to learn how to do it without rebooting.

Here’s how I did it.

First, view the routes to confirm the route is bad:

netstat -rn | grep IP_ADDR

Grab the IP you care about from the “Destination” column. Use it to delete the route:

sudo route -n delete DEST_IP_ADDR

Done!

Fixing a filename in git on a case insensitive filesystem

Thu, 29 May 2025 14:16:28 -0700

My work laptop was provisioned with a case-insensitive filesystem for some strange reason.

This makes renaming stuff in a git repo “fun”:

$mv README.md readme.md
mv: 'README.md' and 'readme.md' are the same file

Here’s a workaround for this problem:

# give the file a temp name
git mv README.md readme_temp.md
git com -m "Rename 1 of 2"

# then name it what you actually want to call it
git mv readme_temp.md readme.md
git com -m "Rename 2 of 2"

Solved!

Grep's Buffering + Pipes

Wed, 28 May 2025 19:59:55 -0700

I got bit by this again today, so I’m writing it down so I can reference it later.

When running docker logs -f CONTAINER_NAME | grep -v "foo" | jq, it is important to consider grep’s buffers.

I am using GNU grep and, by default, it uses block buffering when not connected to a terminal (which is my case, since I piped it to jq). This means jq doesn’t get any input until a large-ish amount of text (4k? 8k?) is sent to grep. Since container I was inspecting logs little, I got zero log lines.

Playing around with trees in Golang

Tue, 20 May 2025 09:44:24 -0700

I was playing around with implementing Depth First Search (DFS) and Breadth First Search (BFS) in Go today.

I made a tree which looked like this…

 0
/ \
1 2
/ \ / \
3 4 5 6
/ \
7 8

I then made some Go code to walk the tree using DFS and BFS:

package main

import "fmt"

// Node is a very basic struct which represents
// a node in the tree.
type Node struct {
 Value int
 Left *Node
 Right *Node
}

// dfs() walks the tree (starting at the provided root node)
// in a depth first fashion. It uses a stack.
func dfs(node *Node) {
 // base case
 if node == nil {
 return
 }

 fmt.Println("DFS visiting:", node.Value)

 if node.Left != nil {
 dfs(node.Left)
 }
 if node.Right != nil {
 dfs(node.Right)
 }
}

// bfs() walks the tree (starting at the provided root node)
// in a breadth first fashion. It uses a queue.
func bfs(node *Node) {
 // base case
 if node == nil {
 return
 }

 queue := []*Node{node}
 depth := 0

 for len(queue) >= 1 {
 for _, node := range queue {
 queue = queue[1:]
 fmt.Printf("BFS visiting: %d (depth: %d)\n", node.Value, depth)

 if node.Left != nil {
 queue = append(queue, node.Left)
 }
 if node.Right != nil {
 queue = append(queue, node.Right)
 }
 }
 depth += 1
 }
}

func main() {
 // define our tree (see above diagram)
 tree := &Node{
 Value: 0,
 Left: &Node{
 Value: 1,
 Left: &Node{
 Value: 3,
 },
 Right: &Node{
 Value: 4,
 },
 },
 Right: &Node{
 Value: 2,
 Left: &Node{
 Value: 5,
 },
 Right: &Node{
 Value: 6,
 Left: &Node{
 Value: 7,
 },
 Right: &Node{
 Value: 8,
 },
 },
 },
 }

 // call our funcs
 dfs(tree)
 bfs(tree)
}

Running the code outputs:

Enums in Go Part Deux - Marshaling and Unmarshaling!

Thu, 15 May 2025 21:04:01 -0700

My blog post from yesterday made me think… how can you marshal and unmarshal enums in Go correctly?

So I modified internal/coffee/coffee.go and added a MarshalText() and UnmarshalText() methods:

package coffee

import (
 "fmt"
 "strings"
)

//go:generate stringer -linecomment -type=Coffee

type Coffee int

const (
 Drip Coffee = iota // drip coffee
 Latte // latte
 Breve // breve
 Cappuccino // cappuccino
)

func (c Coffee) MarshalText() ([]byte, error) {
 return []byte(c.String()), nil
}

func (c *Coffee) UnmarshalText(text []byte) error {
 want := string(text)
 for i := 0; i < len(_Coffee_index)-1; i++ {
 name := _Coffee_name[_Coffee_index[i]:_Coffee_index[i+1]]
 if strings.EqualFold(name, want) {
 *c = Coffee(i)
 return nil
 }
 }
 return fmt.Errorf("invalid Coffee %q", want)
}

I then modified main.go to add a new type named Drink which expected a Coffee in its field:

Enums in Go

Wed, 14 May 2025 10:37:47 -0700

I was asked yesterday how you implement enums in Go. I didn’t know, so I spent some time this morning learning how to do it.

It turns out this is ridiculously easy to do and Go has the stringer tool which makes it super simple. (stringer codegens the code which prints your enum as a string.)

Example

I created a repo with the following structure:

go.mod
main.go
internal/coffee/coffee.go
internal/coffee/coffee_string.go

internal/coffee/coffee.go looks like this:

Workflow Musings

Mon, 05 May 2025 20:25:44 -0700

Getting things ready in advance

I’ve been musing on how ridiculously useful it is to get things ready in advance. Especially the day before.

Examples:

Setting my workout clothes out. (I’m more likely to workout.)
Packing my backpack with everything I need for work in the morning. (No hunting around in the morning for stuff when my brain is waking up and wasting 15 minutes or getting frustrated.)
Setting everything I need to shower and brush my teeth after late-night roller skating in the guest bathroom. (So I can shower there and not wake up my wife.)

It can sometimes feel silly in the moment, but I’ve found it makes it a lot easier to get the outcomes I want in life (e.g., working out, leaving on time, etc.)

Weekly planning sessions

Sat, 01 Feb 2025 09:19:32 -0700

I’ve been doing a weekly planning session for the last five or so years. It is one of the most helpful things I do to organize my life, keep myself physically healthy, and moving forward.

This process has become even more valuable to me since having a child, as I am now responsible for a lot more and time is more scarce.

In this post, I’ll describe what I do, why it’s useful, and how I do it.

Go Test Parallelism

Fri, 18 Oct 2024 07:52:50 -0700

This post documents some testing I did around whether unit tests in Golang are run in parallel.

TLDR: Tests in a given package run serially, unless t.Parallel() is specified.

To test this, I created two files in a directory named gotest:

$ ls
one_test.go two_test.go

// one_test.go
package main

import (
 "fmt"
 "testing"
 "time"
)

func TestOne(t *testing.T) {
 fmt.Println("1 starts:", time.Now().String())
 time.Sleep(5 * time.Second)
 fmt.Println("1 ends:", time.Now().String())
}

// two_test.go
package main

import (
 "fmt"
 "testing"
 "time"
)

func TestTwo(t *testing.T) {
 fmt.Println("2 starts:", time.Now().String())
 fmt.Println("2 ends:", time.Now().String())
}

When I ran the tests, you can see that TestOne blocked TestTwo from running for five seconds:

Go sub-slice gotchas

Sun, 11 Aug 2024 07:30:15 -0700

Thanks to Julia Evan’s latest post, I learned that creating new slices by sub-slicing an existing slice has an important caveat: They can sometimes use the same backing array! 😬

This is important to understand if you mutate the sub-slice.

Take the below example, wherein we accidentally mutate s1!

package main

import (
 "fmt"
)

func main() {
 s1 := []int{0, 1, 2, 3, 4, 5} // len == 6, capacity == 6
 s2 := s1[1:5] // len == 4, capacity == 5

 // Modifies both s1 and s2, because they share the same backing array.
 s2[0] = 10

 // Modifies both s1 and s2, because the length of s2 after adding the new
 // element does not exceed the capacity of the s2 slice.
 s2 = append(s2, 20)

 // Modifies only s2, because adding this element increases the length of s2
 // beyond the capacity of the s2 slice. This allocats a new backing array,
 // copies all elements to it, and then appends 30 to it. So s1 does not get
 // modified.
 s2 = append(s2, 30)

 fmt.Println("s1", s1)
 fmt.Println("s2", s2)
}

Its output is:

Unifi Network Application Upgrade

Mon, 22 Jul 2024 08:29:44 -0700

I run Unifi network gear in my house. As I have multiple wireless access points, I use a controller to manage them so clients can seamlessly roam between them.

I run Unifi’s controller software as a Docker container (from here and here) to save myself from running Yet Another Appliance™ and paying for more hardware. I’ve been running v6 for a while, but recently upgraded to v8.

These are my notes to myself for how I set this up.

Configuring a Git pre-push hook to run unit tests

Wed, 26 Jun 2024 10:42:46 -0700

A coworker turned me onto this lovely technique the other day. You can use a git pre-push hook to run all of your Golang unit tests before pushing.

To do this, make a the following file: $YOUR_REPO/.git/hooks/pre-push The file must be executable.

The file’s contents should be:

#!/bin/sh

if ! go test ./... ; then
 echo
 echo "Rejecting commit. Unit tests failed."
 echo
 exit 1
fi

Easy peasy.

How to care for your Invisalign braces

Sun, 14 Apr 2024 08:42:56 -0700

I wore Invisalign braces from January of 2022 to early 2023. They require a lot of brushing and maintenance while wearing them.

Here’s a few things I did along the way which made that easier.

1. Create brushing stations

You’re going to brush and floss a lot. (Like a lot.) Anytime you eat or drink anything besides water you must remove the Invisalign trays, brush your teeth and trays, and then floss.

Using git worktrees

Wed, 27 Mar 2024 10:33:49 -0700

Have you ever been developing on a feature branch and needed to look at a separate branch on the same repo?

I have.

When this happens, I normally do one of two things:

git stash my changes and change branches
- This is annoying because it’s a lot of steps.
- I also have to remember which stash to pop when I come back to this branch.
Stage all my changes and store them in a work-in-progress commit
- This is better than #1 but doesn’t let you view both branches simultaneously.
- But it’s still annoying if you have files you haven’t staged yet and don’t want to stage yet.

Both these have drawbacks. For example, they don’t let me look at both branches at the same time in my text editor.

How my digital life is backed up

Fri, 22 Mar 2024 20:30:01 -0700

Derek Sivers recently wrote a post explaining how he backups his computers. His post inspired me to improve my own backup strategy and also to write this post.

My computer

I only have two personal computers whose data I care about; my Macbook Pro and my wife’s Macbook Air. The strategies for backing these up are the same, so I’ll just talk about my computer.

It has a lot of important things: files, videos, photos, personal code, and more. I’d be pretty sad and set back if I lost all of it. So I’m pretty exhaustive about my backup strategy, but it ends up taking very little of my personal time because most of it happens with little thought on my part.

About

Tue, 12 Mar 2024 19:58:00 -0800

I am a lifelong learner working in lovely Seattle, Washington as a software developer.

I write services, tooling, and automation in Golang and Python to help manage a security-related cloud service. When I’m not at work, I can generally be found reading, working out, biking, and generally trying to improve myself or learn something new.

See what I’m up to now.

Favorite things

Software:

Sublime Text - best text editor on the market
Things 3 - best todo list I’ve found
Fantastical - the only calendar app you need
Bear - polished markdown notes

Hardware:

Running a subset of Go tests

Thu, 07 Mar 2024 12:33:05 -0800

It is often useful to run a subset of the tests in a Go project. You might do this because you only want to see test results for one package or to run tests faster.

For these examples, assume your project is a Go module named examplemodule. It has the following structure:

examplemodule
|_ go.mod
|_ go.sum
|_ internal
|_ foo
| |_ foo.go
| |_ foo_test.go
|_ bar
|_ bar.go
|_ bar_test.go

Here’s the most useful techniques I use to do this:

Max and min integer values in Golang

Tue, 05 Mar 2024 14:32:02 -0800

Today I needed to use the maximum unsigned 64-bit integer value possible in Golang.

Here is a short program I wrote with some help from Stack Overflow to help me remember how to calculate these without any dependencies.

package main

import "fmt"

const (
 minUint32 = uint32(0)
 maxUint32 = ^uint32(0)

 minUint64 = uint64(0)
 maxUint64 = ^uint64(0)

 minInt32 = int32(-maxInt32 - 1)
 maxInt32 = int32(maxUint32 >> 1)

 minInt64 = int64(-maxInt64 - 1)
 maxInt64 = int64(maxUint64 >> 1)
)

func details[numeric int32 | int64 | uint32 | uint64](name string, num numeric) {
 fmt.Printf("%9s -> dec: %21d\tbin: %65b\n", name, num, num)
}

func main() {
 details("minUint32", minUint32)
 details("maxUint32", maxUint32)

 details("minUint64", minUint64)
 details("maxUint64", maxUint64)

 details("minInt32", minInt32)
 details("maxInt32", maxInt32)

 details("minInt64", minInt64)
 details("maxInt64", maxInt64)
}

Running that shows:

Using 'git commit --fixup'

Tue, 20 Feb 2024 09:37:51 -0800

I learned something new from Julia Evans today.

Git has a --fixup argument when committing files which makes it easy to create fixup commits which can get automatically squashed when rebasing. This is fantastic!

I’ve known about git commit --amend for years, but this allows you to fixup commits which are several commits back without manually moving a bunch of lines around while interactively rebasing…

Let’s assume you have a repo which looks like shown below. 696792e9 is our “bad” commit, which we need to fixup.

Go build tags

Wed, 03 Jan 2024 07:42:31 -0800

Today I learned about Go build tags. Here’s some quick notes to help me remember how to use them.

Assume you have directory like so:

$ ls -1
extra.go
go.mod
main.go

And main.go has contents:

package main

import "fmt"

var numbers = []string{
 "one",
 "two",
}

func main() {
 for _, number := range numbers {
 fmt.Println(number)
 }
}

And extra.go has contents:

//go:build extrastuff

package main

func init() {
 numbers = append(numbers, "three", "four")
}

If you build without any tags, you get this:

Using gonew to easily create template repos

Thu, 14 Dec 2023 20:11:05 -0800

Now that I’ve been writing Golang for a while, when I start a new project, I typically know the sort of layout I’m looking for.

I typically go for something like this:

.
├── cmd
│ └── demo
│ └── main.go
├── go.mod
├── internal
│ └── subpkg
│ ├── subpkg.go
│ └── subpkg_test.go
└── LICENSE

And often there are lots of ascillary files that go along with this, like Makefiles, CI/CD config files, Dockerfiles, docker-compose files, etc.

Checking an error's type in Golang

Thu, 07 Dec 2023 07:22:53 -0800

I was not very familiar with checking an error’s type in Golang, so I spent a few minutes learning about it today. It turns out that it’s incredibly easy to do.

Running the below code shows the output: 2009/11/10 23:00:00 got custom error: err1

package main

import (
 "errors"
 "log"
)

var (
 customErr = errors.New("err1") // create a error, identified by its var name
)

// oops always returns our custom error. Oops!
func oops() error {
 return customErr
}

func main() {
 err := oops()
 if errors.Is(err, customErr) { // check error type with errors.Is()
 log.Fatal("got custom error: ", err)
 }
}

This is doing more than just matching the string of the error, as this does not show any output:

Benchmarking Unnecessary Allocations

Sat, 30 Sep 2023 20:12:53 -0700

I’ve also been thinking more about unnecessary allocations in my Go code and how to avoid them by pre-declaring the length of a slice up front.

Normally, I’d write something like this:

var s []int
for _, val := otherSlice {
 s = append(s, val)
}

Since I don’t specify the size of s, if otherSlice is large, the array underlying s might not be large enough to hold all the values; then a new array will have to be allocated and (I presume) all existing values copied out of it one at a time to fill the new array.

Templating files with Golang

Tue, 19 Sep 2023 20:47:59 -0700

I recently went through How To Use Templates in Go to refresh my memory on Golang templates. I was reminded how great they are and learned several things along the way.

I learned that the below syntaxes are equivalent:

{{ . | len }}
{{ (len .) }}

Here is the program I wrote and tweaked along the way, to refresh my memory in the future:

package main

import (
 "html/template"
 "os"
 "strings"
)

type Pet struct {
 Name string
 Sex string
 Intact bool
 Age string
 Breed []string
}

var dogs = []Pet{
 {
 // This is why you should use html/template and not text/template when
 // rendering HTML. Especially if you don't trust the source of your
 // data!
 //
 // You don't want the template you render to do (potentially) malicious
 // things in your user's webbrowser.
 Name: "<script>alert(\"Gotcha!\");</script>Jujube",
 Sex: "Female",
 Intact: false,
 Age: "10 months",
 Breed: []string{
 "German Shepherd",
 "Pitbull",
 },
 },
 {
 Name: "Zephyr",
 Sex: "Male",
 Intact: true,
 Age: "13 years, 3 months",
 Breed: []string{
 "German Shepherd",
 "Border Collie",
 },
 },
 {
 Name: "Roger",
 Sex: "Male",
 Intact: false,
 Age: "9 years, 7 months",
 Breed: []string{
 "German Shepherd",
 "Border Collie",
 },
 },
 {
 Name: "Missi",
 Sex: "Female",
 Intact: false,
 Age: "99 years, 2 months",
 Breed: []string{
 "Teacup Poodle",
 },
 },
}

// This is how you add functions to your template. You can add functions from
// other packages or define them inline here.
//
// See petsHtml.tmpl for an example of using "join".
var funcMap = template.FuncMap{
 "dec": func(i int) int { return i - 1 }, // Inline!
 "replace": strings.ReplaceAll, // Other package!
 "join": strings.Join,
}

func main() {
 // Create Template, add functions, and load template files.
 tmpl, err := template.New("").Funcs(funcMap).ParseGlob("*.tmpl")
 if err != nil {
 panic(err)
 }

 // Create a file.
 var f *os.File
 f, err = os.Create("pets.html")
 if err != nil {
 panic(err)
 }
 defer f.Close()

 // Execute a template by name with data "dogs" and write to writer "f".
 err = tmpl.ExecuteTemplate(f, "petsHtml.tmpl", dogs)
 if err != nil {
 panic(err)
 }
}

And here are the files I wrote and tweaked along the way:

Goroutines outlive their calling function

Mon, 18 Sep 2023 09:37:32 -0700

While watching a talk by Rob Pike I learned today something about Goroutines which surprised me: Goroutines outlive their calling function.

Said another way, if the function which created the goroutine returns, the goroutine will continue running. (main() is the one exception.) This is fantastic! 🎉

Here’s an example of this in practice.

package main

import (
 "fmt"
 "time"
)

func person(msg string) <-chan string { // Function returns a receive-only channel
 ch := make(chan string) // Create unbuffered channel

 go func() { // This goroutine lives on after person() returns
 for i := 0; ; i++ {
 time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
 ch <- fmt.Sprintf("%s %d", msg, i)
 }
 }()

 return ch
}

func main() {
 james := person("james") // Assign returned channel to variable
 sinah := person("sinah")

 for i := 0; i < 5; i++ {
 fmt.Println(<-james) // Block, waiting for value on channel
 fmt.Println(<-sinah)
 }

 fmt.Println("Done!")
}

Output:

Getting the Git Commit in Go

Fri, 01 Sep 2023 17:28:13 -0700

Go 1.18 added a feature to easily get the Git commit version that the binary was built from.

This is so much easier than the old way of doing it! 🎉

package main

import (
 "fmt"
 "runtime/debug"
)

func main() {
 info, _ := debug.ReadBuildInfo()

 for _, setting := range info.Settings {
 if setting.Key == "vcs.revision" || setting.Key == "vcs.time" {
 fmt.Printf("%s:\t%s\n", setting.Key, setting.Value)
 }
 }
}

$ go build git-version
$ ./git-version
vcs.revision: 4d47dd39d1debbdf10715fd9ff967e09d4347f02
vcs.time: 2023-09-02T00:21:21Z

More info here.

warning

For this to work, you must build with go build -o ./build/foo. Using go build -o ./build/foo/main.go will not work.

Waiting for data from a Go channel with a timeout

Fri, 01 Sep 2023 09:19:32 -0700

The other day I ran into a situation where I wanted my function to block until it received data from a Go channel. But I didn’t want it to block indefinitely. I wanted it to timeout after a few seconds if it didn’t get any data.

My coworker Dan showed me a technique I didn’t know about to easily accomplish this. It wasn’t surprising to learn how easy it was, given that Go has strong support for concurrency out the gate.

Blocking with Channels in Go

Thu, 17 Aug 2023 21:00:44 -0700

Example 1

In the below code, <-messages will block until it gets something on the channel. This prevents main() from exiting until one item is received on the channel.

package main

import (
 "fmt"
 "time"
)

func waitThenSend(msg chan string) {
 time.Sleep(2 * time.Second)
 msg <- "badwolf"
}

func main() {
 messages := make(chan string) // make unbuffered channel

 go func() {
 waitThenSend(messages) // make goroutine, pass in channel
 }()

 <-messages // blocks until channel receives a value

 fmt.Println("done")
}

Example 2

The below example demonstrates using a sync.WaitGroupto keep the program running until all of the goroutines have exited. Data is sent to the function via the unbuffered channel named numbers.

Easy templating with Python and Jinja

Tue, 04 Jul 2023 15:19:23 -0700

At work, I’ve been using both Golang and Ruby to render Nomad jobspec files in a consistent manner across environments.

But Python is my one true love and I wanted to learn how to do it in Python. Turns out I already knew how… you can do it in Jinja2!

I’ve used Jinja2 in the past a lot for Django and Ansible, so this was pretty easy to pick up. Here are some notes for future me when I want to inevitably do this again.

Latency Numbers Every Programmer Should Know

Sat, 24 Jun 2023 08:34:08 -0700

These are useful and I’m putting them here so I can find them easily wherever I am.

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference 0.5 ns
Branch mispredict 5 ns
L2 cache reference 7 ns 14x L1 cache
Mutex lock/unlock 25 ns
Main memory reference 100 ns 20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy 3,000 ns 3 us
Send 1K bytes over 1 Gbps network 10,000 ns 10 us
Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD
Read 1 MB sequentially from memory 250,000 ns 250 us
Round trip within same datacenter 500,000 ns 500 us
Read 1 MB sequentially from SSD* 1,000,000 ns 1,000 us 1 ms ~1GB/sec SSD, 4X memory
Disk seek 10,000,000 ns 10,000 us 10 ms 20x datacenter roundtrip
Read 1 MB sequentially from disk 20,000,000 ns 20,000 us 20 ms 80x memory, 20X SSD
Send packet CA->Netherlands->CA 150,000,000 ns 150,000 us 150 ms
Notes
-----
1 ns = 10^-9 seconds
1 us = 10^-6 seconds = 1,000 ns
1 ms = 10^-3 seconds = 1,000 us = 1,000,000 ns
Credit
------
By Jeff Dean: http://research.google.com/people/jeff/
Originally by Peter Norvig: http://norvig.com/21-days.html#answers
Contributions
-------------
'Humanized' comparison: https://gist.github.com/hellerbarde/2843375
Visual comparison chart: http://i.imgur.com/k0t1e.png

Source: https://gist.github.com/jboner/2841832

Python dataclasses are awesome!

Mon, 22 May 2023 19:46:10 -0700

Last week, I was working on some Python at work and I found myself wishing for an equivalent to Golang’s structs. Rather than passing in a bunch of core data types (string, dict, int, etc.) in an out of methods, I wanted to pass in a single object with predictable attributes. But…. I didn’t want to go through all the trouble of creating a class with a constructor, and passing in all the various attributes.

nil maps in Golang

Sat, 07 Jan 2023 11:38:06 -0800

I’ve been a bit confused for a while over when a map in Golang gets created with a value of nil (its zero value) and when it does not, so I’m writing this to help me remember.

Let’s look at various ways to initialize a map:

package main

import "fmt"

func main() {
 m1 := map[string]string{} // initializes map
 m2 := make(map[string]string) // also initializes map
 var m3 map[string]string // does NOT initialize the map! HERE BE DRAGONS!

 fmt.Println(m1 == nil) // false
 fmt.Println(m2 == nil) // false
 fmt.Println(m3 == nil) // true

 m1["foo"] = "bar"
 m2["foo"] = "bar"
 m3["foo"] = "bar" // panics because the map is NOT initialized, i.e., map is still nil
}

My takeaways from this are:

Thoughts on travel to Hawaii

Tue, 08 Nov 2022 10:19:58 -1000

My wife and I recently went to the Hawaiin islands for a few days for a vacatoin. Here’s what worked well and didn’t well about the trip.

Resorts

We stayed in resorts for the first time. This was new; normally we stay in Airbnbs or the like.

Pros:

Consistent experience.
Clean and nice.
Pools and hottubs.
Safe. We felt very good leaving laptops and the like in the room.

Cons:

Built-in Go HTTP server

Fri, 14 Oct 2022 13:37:26 -0700

Go has a built-in HTTP server in net/http.

Here’s me playing around using it:

package main

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

func hello(w http.ResponseWriter, req *http.Request) {

 fmt.Fprintf(w, "hello\n")
}

func details(w http.ResponseWriter, req *http.Request) {

 resp := []string{}

 resp = append(resp, "Request Details:")
 resp = append(resp, fmt.Sprintf("- Request proto: %s", req.Proto))

 resp = append(resp, fmt.Sprintf("- Headers:"))
 for name, val := range req.Header {
 resp = append(resp, fmt.Sprintf("\t- %s: %s", name, val))
 }

 resp = append(resp, "\n")
 fmt.Fprintf(w, strings.Join(resp, "\n"))
}

func main() {

 http.HandleFunc("/hello", hello)
 http.HandleFunc("/details", details)

 fmt.Println("Started.")
 http.ListenAndServe("127.0.0.1:9999", nil)
 fmt.Println("Exiting.")
}

The /details endpoint returns interesting stuff about the HTTP request, like its protocol and headers:

Fixing: File is not `goimports`-ed (goimports)

Wed, 05 Oct 2022 16:09:26 -0700

The other day, I was linting my Go code with golangci-lint when I got this error:

File is not `goimports`-ed (goimports)

I examined the file and found nothing amiss, but the linter insisted something was wrong.

Eventually, I realized I had used spaces to indent the file rather than tabs. Changing the indent character to tabs fixed it.

I then ran into the same error on a second file. This time, I had a comment which was wrong. There were two spaces before the first word in the comment (see below).

Linux load average

Fri, 16 Sep 2022 14:48:56 -0700

This post documents the high level concepts I need to remember about *nix Load Average.

Load average can been seen in the output of uptime and top:

From uptime:

$ uptime
14:40 up 21 days, 21:48, 5 users, load averages: 2.63 2.75 3.45

From top:

root@blog-server-2:~# top -n 1 | head -2
top - 15:28:37 up 10 days, 12:41, 1 user, load average: 0.04, 0.03, 0.00
Tasks: 95 total, 1 running, 94 sleeping, 0 stopped, 0 zombie
root@blog-server-2:~#

There are 3 decimal numbers shown. They present the load average over three different time scales:

Using entr to get immediate test feedback

Wed, 07 Sep 2022 15:27:15 -0700

Old and new workflows

My dev workflow used to look like this:

Write some code and save it
Change to my Terminal window
Up-arrow to find my command to run unit tests (typically make test)
Press Enter
Wait for tests to run and examine test output

This worked pretty well, but was a lot of manual steps when you figure that I did this dozens (hundreds?) of times per day. That’s a lot of energy spent doing the same thing over and over again.

Go and pass by value

Thu, 01 Sep 2022 18:25:35 -0700

Go normally uses pass-by-value for function calls. When you pass a variable into a function or method, Go will (under the hood) create a new variable, copy the old variable’s value into it, and then pass the new variable (not the original variable) into the function or method.

Non-pointer values

These types behave as described above and are sometimes called non-pointer values:

Strings
Ints
Floats
Booleans
Arrays
Structs

Here’s an example of how these work. Note that the variables myString and si do not point to the same memory address:

Constants in Go

Tue, 16 Aug 2022 08:49:12 -0700

Constants syntax

I always have a hard time remembering the syntax of declaring constants in Go. So here’s some reminders to myself.

It is possible to declare constants one per line like you’d expect. Note that the there are typed and untyped constants as shown here below.

package main

import "fmt"

const vermKnid string = "scram"
const fox = "foxes likes loxes"

func main() {
 fmt.Println(vermKnid)
 fmt.Println(fox)
}

But you can also use a constant declaration group, which does the same thing but is easier to read if you’re declaring a bunch of constants.

Open a file or folder from the macOS CLI

Tue, 09 Aug 2022 09:20:02 -0700

You can open the a file from the macOS CLI with the command open.

To open a file with the default app, use: open $FILENAME
To open the current directory, use: open .
To open a specific directory, use open $DIRECTORY_NAME
To open a URL, use: open $URL

Thanks to this post for teaching me this.

Python type hints

Fri, 05 Aug 2022 16:36:39 -0700

After working with Go for a while, one of the biggest drawbacks to Python for me is that the types of parameters to functions and methods are completely opaque without good documentation.

For example, let’s take this silly function right here:

def my_func(thing1, thing2):
 print(thing1 + thing2)

This function will happily accept strings or ints (or floats, for that matter) as input and depending on the type, will do completely separate things!

Mutexes and concurrent access in Go

Fri, 22 Jul 2022 14:49:09 -0700

Golang has mutexes (short for mutually exclusion) to manage concurrent access to a shared object via multiple goroutines.

Here’s an example (taken from the excellent Go by Example: Mutexes).

package main

import (
 "fmt"
 "sync"
)

type Counter struct {
 mu sync.Mutex
 count map[string]int
}

func (c *Counter) Inc(name string) {

 c.mu.Lock()
 defer c.mu.Unlock()
 c.count[name]++
}

func main() {

 cnt := Counter{count: map[string]int{"james": 0, "spartacus": 0}}

 var wg sync.WaitGroup

 increment := func(name string, n int) {
 for i := 0 ; i < n ; i++ {
 cnt.Inc(name)
 }
 wg.Done()
 }

 wg.Add(3)
 go increment("james", 100000)
 go increment("james", 100000)
 go increment("spartacus", 10000)

 wg.Wait()
 fmt.Println(cnt)
}

This code defines a simple Counter struct with a single method named Inc to increment the count map. Inc is responsible for managing the locking and unlocking of the mutex with c.mu.Lock() to lock it and defer c.mu.Unlock() to unlock it as the method is returning.

Go routines and WaitGroups

Mon, 18 Jul 2022 16:34:10 -0700

Working with Goroutines is simple. You simply pre-prend your function call with go and you’re off and running.

Here’s an example which calls the expensive() function five times before exiting.

package main

import (
 "fmt"
 "time"
)

func expensive(id int) {

 fmt.Printf("Worker %d starting\n", id)

 time.Sleep(time.Second) // Oh, so expensive!

 fmt.Printf("Worker %d ending\n", id)
}

func main() {

 for i := 0; i < 5; i++ {

 go expensive(i)
 }

 fmt.Println("Exiting!")
}

But it has a problem… running the program shows output like this:

Closures in Go

Wed, 13 Jul 2022 14:25:24 -0700

In Go, it’s pretty easy to write an anonymous function.

package main

import "fmt"

func main() {

 func(s string){
 fmt.Println("s is:", s)
 }("hello world")
}

Running the above code produces:

$ go run main.go
s is: hello world

You can even assign the anonymous function to a variable like so:

package main

import "fmt"

func main() {

 myFunc := func(s string){
 fmt.Println("s is:", s)
 }

 myFunc("hello again, world!")
}

Now we get this output from the above code:

Generics in Go 1.18

Tue, 12 Jul 2022 15:22:00 -0700

In Go 1.18, we get access to Genrics. Huzzah!

Here’s an basic example of how to use them:

package main

import (
 "fmt"
)

func PrintAge[age float32 | int64](myAge age) {
 fmt.Printf("age: %s \t type: %T\n", myAge, myAge)
}

func main() {
 var age1 float32 = 30.5
 var age2 int64 = 32

 PrintAge(age1)
 PrintAge(age2)
}

Running the above program gives us the below output. You can see that it happily accepted the float32 and int64 values without issue.

age: %!s(float32=30.5) type: float32
age: %!s(int64=32) type: int64

This saves us from having to either (a) define a separate PrintAge function for every type of number we want to accept or (b) writing the PrintAge to accept type interface{} which would then accept types we don’t want to accept (and having to mess with type assertions and all that).

Go defer

Tue, 20 Jul 2021 07:32:34 -0700

defer in go is used to run a function later on. Specifically, the specified function will run when the enclosing function returns.

There’s no clean equivalent to this in Python that I’ve found.

The quintessential example is closing a file handle as your program exits.

Example

package main

import (
 "fmt"
 "os"
)

func main() {
 file := createFile("/tmp/testingdefer.txt")
 defer closeFile(file)
 writeFile(file)
}

func createFile(path string) (file *os.File) {
 fmt.Println("creating file: ", path)
 file, _ = os.Create(path) // skipping error handling for brevity
 return
}

func writeFile(file *os.File) {
 fmt.Println("writing file")
 fmt.Fprintln(file, "here is some data for you!")
}

func closeFile(file *os.File) {
 fmt.Println("closing file")
 file.Close() // skipping error handling for brevity
}

Empty Go Interfaces

Sun, 11 Jul 2021 15:10:58 -0700

When declaring function parameters in Go, you must type the incoming data. Here’s an example:

package main

import "fmt"

func print_stuff(s string) {
 fmt.Println(s)
}

func main() {
 print_stuff("Passing string!")
}

s string indicates that we’re passing a variable of type string into the function. This prevents us from from passing into variables of any other type. For example, this will fail with ./prog.go:10:17: cannot use 42 (type untyped int) as type string in argument to example_str if you try to pass an integer.

Line beaks in file names on Linux

Tue, 02 Feb 2021 22:01:33 -0800

Today I accidentally created a file whose name had a newline character in it. I didn’t notice it when I did it, but here’s how it showed up in my shell. There was a directory whose name shared the first few characters of the filename.

[22:07] james_simas@widget /var/tmp $ ls o*
oops? <--- Suspicious file!
oops: <--- Directory

I tried to delete it:

[22:07] james_simas@widget /var/tmp $ rm 'oops?'
rm: oops?: No such file or directory

Then I realized the my shell wasn’t interpreting the character right:

Translating characters with tr

Thu, 14 Jan 2021 18:41:51 -0800

I recently was having to work with Ansible for several days to deploy changes globally across prod. I was storing my playbook limit in a file like so:

[18:45] james_simas@widget ~/Downloads $ cat limit.txt
host1.domain.com
host2.domain.com
host3.domain.com

At one point, I needed to use supply the list of hostnames in BASH, but rather than having them be newline separated, I needed them to be separated by commas like this:

host1.domain.com,host2.domain.com,host3.domain.com

I didn’t want to modify my original files (I still needed them) and this seemed like a problem somebody else has problably solved. I Googled a bit and found an answer using tr.

How to use extra_vars_path in the tower_job_template Ansible module

Thu, 19 Mar 2020 21:20:35 -0700

Today I was using Ansible’s tower_job_template module in a playbook. I needed to add extra variables to the job template, but Ansible’s public documentation of the the tower_job_template module had no examples of how to do this. I was unable to find any compelling examples on Google.

I was a bit of poking around the Ansible API, it turns out this was far easier than I had anticipated.

Without further ado, here’s how you use extra_vars_path:

Converting blog to Terraform & Ansible

Sat, 05 Oct 2019 14:33:22 -0700

Setting up my blog has always been easy. Previous to today, you just had to:

Provision an Ubuntu 18 VM somewhere (I’ve been using Digital Ocean)
Install Apache and remove its default website
Use Hugo to generate the site’s static files and copy them to the VM host
Done!

But, never being one to sit still, I’ve decided to up my game and move to automatic provisioning with Terraform and Ansible.

Why? Because it’s fucking cool, that’s why!

Operating on a subset of lines with sed

Wed, 11 Sep 2019 18:07:33 -0700

Today a coworker posed an interesting question to me.

Given a BIG-IP configuration file with thousands of records like this…

gtm pool /Common/p_example {
members {
/Common/2001:668:fc78:0:f811:3ef2:fed7:98cc:vs6_2001_668_fc78_0_f811-3ef2-fed7_98cc-80 {
order 0
}
}
monitor /Common/gateway_icmp
}

…how can we easily replace every colon in the name : with \\:?

In short, /Common/2001:668:fc78:0:f811:3ef2:fed7:98cc:vs6_2001_668_fc78_0_f811-3ef2-fed7_98cc-80 needed to become /Common/2001\\:668\\:fc78\\:0\\:f811\\:3ef2\\:fed7\\:98cc\\:vs6_2001_668_fc78_0_f811-3ef2-fed7_98cc-80.

This must only be done on the lines with start with /Common and which also contain the string vs6. He could not guarantee that colons would not be found elsewhere in the file.

Using SMS is like Killing Whales for Oil

Thu, 15 Aug 2019 20:54:34 -0700

If you’ve known me for a while, you probably know that I have a soap box. This soap box has “STOP USING SMS” written on the side in red Sharpie.

It’s true. I hate SMS/MMS. The protocols are terrible and like hunting whales for oil. (Sure, you could do that, but why would you when there are so many better technologies out there?!)

The Pain Points

Slow

Text messages are slow to deliver. Seriously. I often experience delays of several seconds (or tens of seconds!) waiting for text messages to send. This is especially true if I’m in my work’s office building which has many areas where cell signal is weak.

Notes on sed

Sat, 15 Jun 2019 15:44:09 -0700

I’ve always been a bit hit-or-miss with sed and haven’t understood it to the level to which I wanted. Today I aimed to change that and these are my notes from sitting down to learn it.

Replace a string in a file (first occurrence per line only):

cat file.txt | sed 's/oldstring/newstring/'

Replace a string in a file (all occurrences per line, i.e., globally):

cat file.txt | sed 's/oldstring/newstring/g'

Use your own delimiters by just dropping them in place of /:

Digital Declutter Reflections

Sat, 23 Mar 2019 11:40:30 -0700

A few days ago, I finished my Digital Declutter Experiment. Here’s what I accomplished:

Successfully fixed my leaky kitchen faucet
Attempted to replace the burned out lights in my car’s climate control dashboard, but did not succeed.
- It turns out you have to take apart a ton of the dashboard to replace the tiny light-bulbs which burned out. I spent an hour and a half on it before deciding it was more work than it is worth to me.
Worked out 3-5 times at the gym each week.
- This goal got severely impeded by a nasty cold I’ve had off and on for several weeks.
- It became clear that the amount of energy I was expending in exercising was causing me to relapse into sickness again, so I’ve had to take more time off than I wanted or anticipated.
Read several books
Started a puzzle with Sinah
Significantly cut down my time on-line
Had significantly more face-to-face interactions with friends and family

Things I’ve learned

YouTube Can Be Awesome

YouTube was very helpful in fixing my leaky faucet. The tutorials I found were accurate, clear, and to the point. This made fixing my faucet significantly easier than it would have otherwise been.

TCL - Part 2

Fri, 22 Feb 2019 20:46:48 -0800

Lists (Continued)

Appending to lists is simple with lappend:

Note: lappend takes just the name of the list. It updates the specified list, so you do not have to use set.

% set list {this is {a list}}
this is {a list}
% lappend list {more stuff here}
this is {a list} {more stuff here}
%
% puts $list
this is {a list} {more stuff here}

Inserting into a list is done with linsert. It is zero-indexed:

% set list [linsert $list 3 {of stuff with}]
this is {a list} {of stuff with} {more stuff here}
%
% puts $list
this is {a list} {of stuff with} {more stuff here}
%

Split

split accepts:

Digital Declutter Experiment

Tue, 19 Feb 2019 14:55:05 -0800

I recently finished “Digital Essentialism” by Cal Newport. As part of my resolution to get more value from the books I read, I will be conducting his recommended “Digital Declutter” experiment for the next 30 days.

As such, here are the technology rules I will follow from 2019-02-19 to 2019-03-21.

The Rules

Email
- My personal email will be checked once per day.
- I already do this, but feel like it is a useful habit, so I am continuing it.
Text messaging / message services
- All group threads will be muted.
Reddit
- I will not use Reddit during this time. It’s a black hole!
Streaks
- I will not use my habit tracking app during this time and will pause all habits it is tracking.
Streaming Video Media
- Includes:
  - YouTube
  - Netflix
  - Amazon Prime
  - etc.
- I will limit this to no more than 5 hours per week. It must be with my wife or friends. I will track it with a sticky note next to the TV.
IMDB
- I will not use IMDB during this month.

Exemptions and Operating Procedures

This a list of apps or services I which are exempted from this experiment.

TCL - Part 1

Mon, 18 Feb 2019 11:57:54 -0800

I’ve been improving my knowledge of TCL since I’m starting to work with a lot of iRules (which are based on TCL) in my current position. With that said, here’s some notes I took from my latest round of studying and learning.

Many thanks to Exploring Expect by Don Libes for facilitating my learning!

Getting setup

Installing TCL on Ubuntu: apt install tcl

Launching the TCL shell: tclsh

Variables

Setting a variable: set i 100

Some of my favorite things

Sat, 16 Feb 2019 15:38:26 -0800

In no particular order, here are some things which delight me:

Books & Blogs

Cal Newport’s books and blog
- This man has significantly improved my working life and made me more effective in general.
- I strongly recommend Deep Work and Digital Minimalism. Digital Minimalism was responsible for helping me kick my Reddit and YouTube habit.
The Coffeehouse Investor
- This book kickstarted my Save For Retirement Like A Motherfucker(tm) plan.

Software

Sublime Text
- I basically live in a text editor for work, so a great text editor is essential.
- This is some of the best money I’ve ever spent a piece of software.
Things 3
- What do you get when you combine people who really get good design and engineers? Things 3. That’s what.
- This is easily the best to-do list app that I’ve ever used.

Other

Tom Bihn
- They make some of the most enjoyable to use travel gear out there.
- I own many products by them and my favorite is their packing cubes.
GoRuck GR1
- This is the best backpack I’ve ever owned. Hands down. I had no idea I could enjoy using a backpack so much.

Initial commit

Sat, 16 Feb 2019 13:52:13 -0800

I’ve tried this blog thing before. It hasn’t stuck (probably because I wrote in the style I learned in college.)

I’m giving it another shot, but this time it will be much more free form and less academic.

I will use this to record anything I find interesting.

ab

Mon, 01 Jan 0001 00:00:00 +0000

Send 10,000 requests, using 10 sockets at a time: ab -n 10000 -c 10 https://10.10.10.10/
Send requests with a BIG-IP persistence cookie: ab -n 10000 -C BIGipServerMyPool=1677787402.36895.0000 http://10.10.10.10/

ansible

Mon, 01 Jan 0001 00:00:00 +0000

Specify vault file password file via env var: export ANSIBLE_VAULT_PASSWORD_FILE=/path/to/file

bash

Mon, 01 Jan 0001 00:00:00 +0000

Miscellaneous:

Run script with verbose output: bash -v
Check for syntax errors: bash -n
Show xtrace info: bash -x
- Lines which start with + are executed in the shell
- Lines which start with ++ are executed in a sub-shell
Loop over alphabet with upper and lower case: for l in {{A..Z},{a..z}}; do echo $l ; done
Print text in beautiful columns by piping to: column -t
Echo a string to stderr: >&2 echo Hello, world.

Keyboard shortcuts:

curl

Mon, 01 Jan 0001 00:00:00 +0000

Display response code and total time: curl -s -w "%{http_code} - %{time_total}\n" -o /dev/null www.jamessimas.com
curl multiple IPs with one command: curl 10.20.20.8[0-9]:80/
Overriding DNS: curl --resolve "www.jamessimas.com:80/10.11.12.13" www.jamessimas.com

cut

Mon, 01 Jan 0001 00:00:00 +0000

Delimited:

The delimiter in the below examples is :.

Show field 1: cut -f 1 -d : /etc/password
Show field 2 and sort results numerically: cut -f 2 -d : /etc/password | sort -n
Show all fields after field 1: cut -d: -f 2:
Show fields 1 through 2: cut -d : -f1-2

Miscellaneous:

Cut 10 from start of line: cut -c -10

dig

Mon, 01 Jan 0001 00:00:00 +0000

Display short response: dig +short www.google.com
Display only answer section: dig +noall +answer www.google.com
Specify source address for query: dig -b <source address[:#port]>
Specify DNS server to query: dig @DNS_SERVER www.google.com
Use ends0: dig @DNS_SERVER +subnet=10.11.12.13 1.1.1.1

git

Mon, 01 Jan 0001 00:00:00 +0000

Branching and Checkout:

Clean up local banches:
1. git remote prune --dry-run origin
2. git remote prune origin
Update local branch without it being checked out: git fetch origin src_branch:local_branch
Show which remote branch local branches are tracking: git branch -vv
Display branches by last commit date: git for-each-ref --sort=-committerdate refs/heads/
Copy files/directories from another branch to current branch: git checkout source_branch -- path/to/dir/ path/to/file.txt
Reset to a particular commit without losing changes:
- Reset to one commit past most recent: git reset HEAD^
- Reset to particular commit: git reset COMMIT_ID

Diffing branches:

golang

Mon, 01 Jan 0001 00:00:00 +0000

go doc

Run web server: godoc -http=localhost:8888 -index -links
View web server: http://localhost:8888
- Tip: Add ?m=all to URL to show unexported types, funcs, etc.

go test

Run all tests:

Run all tests: go test ./...
Run all tests in package: go test modulename/pkg/packagename/
Run all tests in file: go test path/to/file_test.go

Run subset of tests:

Run function tests: go test path/to/file_test.go -run FUNCTION_TEST_NAME
Run a single test in function tests: go test path/to/file_test.go -run FUNCTION_TEST_NAME/test_name_here

Tips:

macOS

Mon, 01 Jan 0001 00:00:00 +0000

Allow an app to run

sudo xattr -rd com.apple.quarantine /path/to/the.app

Disable emoji predictions in macOS Sonoma and higher

sudo defaults write /Library/Preferences/FeatureFlags/Domain/UIKit.plist emoji_enhancements -dict-add Enabled -bool NO

Source: https://www.reddit.com/r/MacOS/comments/16wzdk9/is_there_a_way_to_turn_off_the_new_emoji/

Dock

Configure auto-hide delay:

# set to 200ms (default)
defaults write com.apple.dock "autohide-delay" -float "0.2" && killall Dock

# set to 30ms
defaults write com.apple.dock "autohide-delay" -float "0.03" && killall Dock

# set to immediate
defaults write com.apple.dock "autohide-delay" -float "0" && killall Dock

Finding what processes are using a TCP port

sudo lsof -nP -iTCP -sTCP:LISTEN

Time Machine

Configure backup speed:

Now

Mon, 01 Jan 0001 00:00:00 +0000

Last updated: 2025-08-22

Where am I located?

Seattle, WA 🌦️

What do I do for work?

I’m still a software developer for F5. 💻 I write back-end tooling, services, and automation to make managing a cloud service at-scale possible.

I spend most of my time working in Golang nowdays and write tooling to orchestrate backend infrastructure.

What else is going on?

I’m in love with VIM-keybindings for coding.

I switched to the Ghostty terminal.

rsync

Mon, 01 Jan 0001 00:00:00 +0000

Copy directory recursively with status bars:

rsync -avh --progress -e ssh /source/dir/ user@remotehost:/dest/dir/

sort

Mon, 01 Jan 0001 00:00:00 +0000

Numericaly sort file. Fields are separated by :. Use key in position 2: sort -n -k2 -t : /etc/password
Sort by size of directories/files: du -h | sort -n

ssh-add

Mon, 01 Jan 0001 00:00:00 +0000

Add identities:
- Default: ssh-add
- Specific: ssh-add path/to/identity
- With 1h lifetime: ssh-add -l 3600 path/to/identity
List identities: ssh-add -l
Locking:
- Lock w/ password: ssh-add -x
- Unlock: ssh-add -X
Delete identity: ssh-add -d path/to/identity
Delete all identities: ssh-add -D

tarsnap

Mon, 01 Jan 0001 00:00:00 +0000

List archives: tarsnap --list-archives | sort
List size of all archives: tarsnap --print-stats
Create archive: tarsnap -v -c -f ARCHIVE_NAME /path/to/file /path/to/dir
Restore archive: tarsnap -v -x -f ARCHIVE_NAME
Delete archive: tarsnap -d -f ARCHIVE_NAME

Useful doc: https://www.tarsnap.com/simple-usage.html

tmux

Mon, 01 Jan 0001 00:00:00 +0000

Favorite commands

Create session: tmux new [-s <session name>]
Detach session: Ctrl + b, d
Attach session: tmux a -t <session name>
Rename session (while in it): Ctrl + b, $
List sessions: tmux ls OR Ctrl + b, s
Kill session: tmux kill-session -t <session name>
Go to previous session: Ctrl + b, (
Go to next session: Ctrl + b, )

Scrolling

Scroll session: Ctrl + B + [ Page Up | Page Down ]
Enable scroll mode: Ctrl + b, [
Exit scroll mode: q

Panes

Move pane left/right: Ctrl + B + [ { | } ]
Toggle between pane layouts: Ctrl + b + spacebar
Split window into panes vertically: Ctrl + b + "
Split window into panes horizontally: Ctrl + b + %
Kill pane: Ctrl + b + x
Switch to pane to the direction: Ctrl + b + <arrow key>

Helpful websites

Create new session: tmux -S /tmp/shareds new -s shared
Have them connect: sudo tmux -S /tmp/shareds attach -t shared

Source: https://www.howtoforge.com/sharing-terminal-sessions-with-tmux-and-screen