Golang on Ty Scales

File Descriptors

Tue, 24 Mar 2026 17:00:08 -0700

File descriptors are integer values that processes and the linux kernel use to manage open files. Any process that is spawned starts with 3 file descriptors: stdin(0), stdout(1), and stderr(2). In bash we can list the file descriptors of an empty process like this.

sleep 2 & ls -l /proc/$\!/fd
[1] 4473
total 0
lrwx------  0 -> /dev/pts/0
lrwx------  1 -> /dev/pts/0
lrwx------  2 -> /dev/pts/0

What happens when we open a new file? The process tells the kernel “I’d like to open a file”, and the kernel says “It’s now open, when you want to write to it, just refer to it by this descriptor value N”.

Listening for TLS Handshakes

Sat, 27 Dec 2025 12:45:15 -0800

Golang’s standard library has support for TLS servers out of the box. For testing purposes, you can generate a cert with openssl

openssl req -new -newkey rsa:4096 -x509 -sha256 -days 365 -nodes -out server.crt -keyout server.key

and use http.ListenAndServeTLS to spin up a sever

package main

import (
	"fmt"
	"net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", func(w http.ResponseWriter, req *http.Request) {
		fmt.Fprintf(w, "welcome to my secure server\n")
	})

	fmt.Println("starting server")
	err := http.ListenAndServeTLS(":443", "server.crt", "server.key", mux)
	if err != nil {
		fmt.Printf("Server failed: %s\n", err)
	}
}

confirm that it works with curl.

Base 4 Repunits

Sat, 15 Nov 2025 22:22:21 -0800

In my previous post I wrote about what primes look like in base 2, and how mersenne primes take on the particular pattern of all 1s. A number in any base consisting of all 1s is called a repunit

1:   1
3:   11
7:   111
31:  1111
127: 1111111

Another interesting pattern to look at in base 2 is alternating 1s and 0s.

5:  101
21: 10101
85: 1010101

A number in this sequence can be generalized as $2^0 + 2^2 + 2^4 … + 2^n$ Where n is the number of 1s in the binary number.

Base 2 Primes

Sun, 02 Nov 2025 19:10:06 -0800

In the base 10 number system, All prime numbers greater than 10 end in 1,3,7, or 9. What if we looked at primes in base 2, does that reveal patterns of its own?

In Go, the math/big package provides a ProbablyPrime method which accurately reports primes up to $2^{64}$

import (
    "math/big"
    "fmt"
)
func printPrimesTo(n int64) {
	var i int64
	for i <= n {
		isPrime := big.NewInt(i).ProbablyPrime(1)
		if isPrime {
			fmt.Printf("%d: %b\n", i, i)
		}
		i++
	}
}

The prime numbers up to 100 represented in base 2:

Why Reversing Sha256 Is Hard

Sun, 17 Aug 2025 18:20:47 -0700

sha256 is an algorithm that modifies eight 32 bit integers in place and returns a new set of 8 integers. The starting 8 integers are always the same:

// first 32 bits of the fractional parts (the decimals) of
// the square roots of the first 8 primes
h0 := uint32(0x6a09e667)
h1 := uint32(0xbb67ae85)
h2 := uint32(0x3c6ef372)
h3 := uint32(0xa54ff53a)
h4 := uint32(0x510e527f)
h5 := uint32(0x9b05688c)
h6 := uint32(0x1f83d9ab)
h7 := uint32(0x5be0cd19)

The digest for the letter ‘a’

Programming Without Structs

Thu, 03 Jul 2025 18:25:56 -0700

Krzysztof Kowalczyk writes in his blog post on the go programming language:

Go has shown that you can have a popular language without enums. I don’t think you could have a popular language without structs. There’s a line below which the language is just not useful enough.

What would it look like if we didn’t have structs? The core idea of struct is a covenient way to store and access data. We woud need to substitute our struct for another primitive type that can hold data. A map provides similar lookup capabilities by using a key, with less gaurantees that a field might even be present.

XML in Go

Wed, 12 Feb 2025 15:30:37 -0800

Decoding

In this section we’ll examine the rules of the xml decoder and provide examples for each.

1. If the struct has a field type []byte or string with tag “,innerxml”, Unmarshal accumulates the raw XML nested inside in that field. The rest of the rules still apply.

x := `<address>
        <street>123 Main St</street>
    </address>`

type Address struct {
    Contents string `xml:",innerxml"`
}
var addr Volume
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Println(addr.Contents)
//  <street>123 Main St</street>

2. If the struct has a field named XMLName of type Name, Unmarshal records the element name in that field.

x := `<address>
        <street>123 Main St</street>
    </address>`

type Address struct {
    XMLName xml.Name
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%+v", addr.XMLName.Local)
// address

3. If the XMLName field has an associated tag of the form “name” or “namespace-URL name”, the XML element must have the given name (and, optionally, name space) or else Unmarshal returns an error.

x := `<address>
        <street>123 Main St</street>
    </address>`

type Address struct {
    XMLName xml.Name `xml:"city"`
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
    //expected element type <city> but have <address>
}

4. If the XML element has an attribute whose name matches a struct field name with an associated tag containing “,attr” or the explicit name in a struct field tag of the form “name,attr”, Unmarshal records the attribute value in that field.

x := `<address id="999">
        <street>123 Main St</street>
    </address>`

type Address struct {
    Id string `xml:"id,attr"`
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Println(addr.Id)
//999

5. If the XML element has an attribute not handled by the previous rule and the struct has a field with an associated tag containing “,any,attr”, Unmarshal records the attribute value in the first such field.

x := `<address id="999" span="888">
        <street>123 Main St</street>
    </address>`

type Address struct {
    Id        string `xml:"id,attr"`
    OtherAttr string `xml:",any,attr"`
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%+v", addr)
// {Id:999, OtherAttr:888}

6. If the XML element contains character data, that data is accumulated in the first struct field that has tag “,chardata”. The struct field may have type []byte or string. If there is no such field, the character data is discarded.

x := `<address>
        <street>123 Main St</street>
    </address>`

type Address struct {
    Street struct {
        Text string `xml:",chardata"`
    } `xml:"street"`
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Println(addr.Street.Text)

7. If the XML element contains comments, they are accumulated in the first struct field that has tag “,comment”. The struct field may have type []byte or string. If there is no such field, the comments are discarded.

x := `<address>
        <!-- an xml comment -->
        <street>123 Main St</street>
    </address>`

type Address struct {
    Comment string `xml:",comment"`
}
var addr Address
err := xml.Unmarshal([]byte(x), &addr)
if err != nil {
    log.Fatal(err)
}
fmt.Println(addr.Comment)
// an xml comment

8. If the XML element contains a sub-element whose name matches the prefix of a tag formatted as “a” or “a>b>c”, unmarshal will descend into the XML structure looking for elements with the given names, and will map the innermost elements to that struct field. A tag starting with “>” is equivalent to one starting with the field name followed by “>”.

This one is worth dividing in to several examples: The most basic is when a sub-element name that matches a tag.