0xDEADBEEF

Material Objects I Enjoyed in 2025

Fri, 28 Nov 2025 18:00:00 +0000

Sat at a coffee shop in Wichita, Kansas for Thanksgiving and I thought I’d write something that isn’t an email, a Slack message, a line of code, or a comment on a Notion doc for once. So, as a proud consumer of the world, here’s a list of material things that brought me joy this year.

Small Coffee Cups

This year, I have been exploring new ways to drink coffee. I wanted it become more of a ritual than a habit. Small cups have been very helpful with this process. They slow things down. They ask you to pay attention to the drug you are ingesting.

The two cups below feel almost like wine glasses. They hold the aroma in a way that invites you in. Before you take the sip, the cup first greets with you a pleasant scent.

Lately, I’ve been leaning into lighter, funkier, juicier coffees. Turns out they get even tastier as they start to cool. These small cups help with that.

Contax T2

This thing is built like a tank. But takes photos that feel delicate and precise.

Early this year, I dropped it on concrete while one too many pints in and wrapped the front cover. After a massive bill and a flight to Brooklyn, it's healthier than ever.. thankfully.

Lesson learned that despite the titanium housing and me using the word "tank" to describe it 3 sentences ago, it still is a camera that is decades old and should be handled with maximum respect.

My Glasses

I've been wearing glasses since elementary school and I've genuinely only had two pairs that I LOVED. These are one of them.

Made by a Korean brand, named lash | retrospect, they probably remind you of Moscots. But as an Asian, it's been very hard to find a pair of Moscots that fit me well. So think of these as Moscots, made by folks who have low nose bridges (Asians).

They're sturdy and they almost act like horse blinders. They frame my peripheral vision and make me feel more focused and contained. The world is already too stimulating. These help narrow things just enough so I can stay present.

1461, Made in England

These boots make me feel ready for the day. I'm on my third pair of Docs - same model - now. This time, I treated myself by getting the "Made in England" version of the boots.

Breaking them in was tough. A few blisters. A few slow walks. I'm only a month in so it's too early to speak in absolutes. But so far, they feel sturdier than my "Made in China" boots.

I almost strayed toward a pair of Solovairs, but the moment I put them on, my feet did not like them.

For now, I'm sticking with the Docs.

The Coffee Scoop

This thing does one thing and it does it well. I use it every morning and the amount of joy this tiny scoop from Kinto has brought me is remarkable.

It scoops the perfect amount of coffee beans and feels great to hold with two fingers. Its size lets me maneuver it into any coffee bag or storage opening.

For me, this was a great reminder that material objects that bring you joy can be as simple as a scoop.

American Beaujolais

Yes, American Beaujolais is a thing. Made by a semi-controversial(??) winery Las Jaras, this thing goes down like juice.

A Matter of Concrete

From packaging, to their bean selection, you can't go wrong with them. Pink bourbon is their specialty. If you are in SF, you can sometimes find them at The Coffee Movement.

Glow-in-the-Dark Nalgene Bottle

Hello fellow hydration homies. I discovered that Nalgene makes a glow-in-the-dark bottle a couple years ago, and I've never looked back.

This thing looks great during the day. But it truly shines - ha - at night. Leave it beside your bed and it acts as a tiny beacon of light that helps you find your way back after using the restroom in the middle of the night.

The Weekender Bag

I daily drive this bag and it fits everything I needs to carry. Sneakers, dirty gym clothes, a protein shake that doesn't smell great, emergency Vitamin C pills, and a laptop. The only downside is that people keep asking what I'm hauling around in a huge bag.

Whenever they do, I give a cheeky "you wouldn't want to know - winky face" and it always turns into a fun conversation starter.

The Perfect White T-shirt

Every guy is probably always looking for the "perfect white t-shirt". For me, this is it.

Merz B. Shwanen is a brand that became famous thanks to the TV show "The Bear" and I have to admit it, I fell for the hype. But I am glad I did. There, I said it.

The German attention to detail and their pride in making physical things well really comes through here.

Man in the Arena

Thu, 25 Jan 2024 06:23:11 +0000

Hello, Internet. It’s been a while since I have posted anything here - precisely 1,634 days or 53.68 months - but I am back. A lot has happened during this time; some notable events include:

I moved countries twice
Worked at 2 of my dream companies
Left both of those companies
Solved my immigration puzzle, enabling me to finally start a company
Joined SPC, created a company, and started working with my co-founder

And here we are. During these 1,634 days, I’ve encountered many interesting experiences and insights. I’ve decided to resume writing on this blog to share these experiences and thoughts with you, one small piece at a time. If you resonate with or learn something new from these pieces, fantastic. If not, I encourage you to message me on X. Let’s have a pleasant conversation and enlighten each other.

As a prelude to upcoming posts, here’s a sample of topics and thoughts currently on my mind:

Startups can take many forms. What is the ideal form that I want to create and nurture with a co-founder?
If ideas are seeds, what is my preferred approach to produce, nurture, and grow them into self-sustaining & profitable entities?
The AI golden age is here. What will living in the future look like? How can I ride the wave of this exciting technology?
and more…

Before I go, here are some quotes that deeply resonated with me.

It is not the critic who counts: not the man who points out how the strong man stumbles or where the doer of deeds could have done better. The credit belongs to the man who is actually in the arena, whose face is marred by dust and sweat and blood, who strives valiantly, who errs and comes up short again and again, because there is no effort without error or shortcoming, but who knows the great enthusiasms, the great devotions, who spends himself in a worthy cause;

Teddy Roosevelt

“Turning something from an idea into a reality can make it seem smaller. It changes from unearthly to earthly. The imagination has no limits. The physical world does. The work exists in both.

Rick Rubin

Curious about what I am working on? Stay up to date here.

Xcode Auto Generated Interfaces

Wed, 18 Jul 2018 06:23:10 +0000

If you have ever called Objective-C code from Swift, you may have noticed the “Generated Interfaces” feature in Xcode. But have you noticed the details of the said “generated interfaces”?

For those of you who don’t know what I’m talking about, Xcode has a feature where you can view the automatically generated Swift interfaces of Objective-C files from the editor. This is way, you can see how your Objective-C expressions are parsed into their Swift counterparts, before compiling anything.

Look closely 👓

That’s cool and all but did you notice how objc expressions were exactly parsed into their Swift counterparts? If you didn’t, let me point them out to you.

Initializers

- (instancetype)initWithName:(NSString *)name age:(NSInteger)age;
- (instancetype)initName:(NSString *)name;
- (instancetype)initFor:(NSInteger)years;

🔻 Generated Interfaces

init(name: String, age: Int)
init(name: String)
init(for years: Int)

Notice that the initWithName is automatically shrunk to init(name:) to follow Swift’s naming style 😱. This allows you to name your objc functions without worrying about how they are going to look in Swift.

Also, notice how initFor is separated into init(for:). Cool, eh?

Functions

Assuming the above initializers are for the Animal class, let’s make our Animal do something by adding some functions.

- (NSInteger)sleepFor:(NSInteger)minutes; 
- (NSInteger)playAt:(Location)location for:(NSInteger)minutes; 
- (NSInteger)playWith:(Toy)toy                         

🔻 Generated Interfaces

func sleep(for minutes: Int) -> Int
func play(at location: Location, for minutes: Int) -> Int
func play(with toy: Toy!) -> Int

Here, things seem pretty straightforward but once again, notice the details! The sleepFor:, playAt:, playWith: have been parsed as sleep(for:), play(at:) and play(with:).

enums

Now that the Animals can do something, let’s make some Locations where we can play with our Animals.

typedef NS_ENUM(NSInteger, Location) {
    LocationPark,
    LocationHome,
    LocationLake
};

Notice how I named the enum cases like how any good objc developer should; TypeNameCaseName.

That’s cool but Swift favors simplicity and readability when it comes to naming. Thankfully, Xcode automatically takes care of that for you, again.

public enum Location : Int {
    case park
    case home
    case lake
}

Now look at the below Swift code that is calling objc code. Doesn’t it look like you are calling native Swift code?

guard let 🦄 = Animal(name: "Shadowfax", age: 9000) else {
    fatalError("neighhhhh")
}
        
🦄.play(with: .boomerang)
🦄.play(at: .park, for: 10)

Wrapping Up

Well, I hope you found that to be some what interesting. In the next post, I will maybe look into how this is done behind the scenes 😎

Here’s a sample Xcode project for you to play around with.

Open-source self-diagnostics

Sat, 23 Jun 2018 02:49:23 +0000

☠️ Warning: This post may be too much for the faint hearted. Please proceed with caution. Viewer discretion is advised.

Open source is great. You get great software for free and meet great people while doing it. However, like most things, open source has its dark-sides.

Because the world of open source is purely online and takes place on the fricking internet, it’s very tempting for people to turn into assholes. But please, please, don’t be an asshole. We have a good thing going on and it would be great if we can keep that going.

Now, you may be thinking, “Hey asshole, I’m not an asshole. Who are you calling an asshole, asshole?”. Well, consider this blog post as a self-diagnostic test to find out if you are truly an asshole or not.

Symptom #1. Do you use words such as “simply” or “just”?

e.g. Just integrate X with Y. After that, simply do X on Y to do Z.

Hey asshole, not everyone is a superstar programmer like you. While it may be easy for you, it may be hard for others. Using the j-word and the s-word is the easiest way to make other people shitty.

Prescription 💊

Just dont use the j-word and the s-word.

If that’s too much for you, just point them to a stackoverflow answer, blog post, or a reference material. Let other people be the asshole for you.

Symptom #2. Do you give out orders?

e.g. Do this and that

No one likes being ordered to do something. And considering the nature of open source, there is no reason why that person should listen to you; an asshole. It’s a miracle in the first place that these people made their code open to the public for everyone to use. So, if you want them to do something for you, try being nice pretty please.

You may now be saying “I said those things to help this repo get better.” That’s very nice of you but you are doing the exact opposite because this is how things usually go down.

You give out orders (like an asshole)
Repo maintainer reads your shitty comment
Maintainer gets pissed
Maintainer gets sad
Maintainer tries to keep up with all your shitty comments
Maintainer gets burnt out and stops giving any shits
All pull requests are ignored
Repo goes to shit

Prescription 💊

Try to format your shitty comments into less-shittier comments. In other words, ask nicely. Once again, if that’s too hard for you, try using these pre-constructed sentences.

What do you think about doing ___?
How do you feel about doing ___?
Have you thought about doing ___?
If I were you, I would do ___.
That’s a great idea but I would do ___ if I were you.

If saying these make you feel weird or uncomfortable on the inside, try using these things called emojis. They make you seem like less of an asshole with minimum effort. If you are new to the whole thing, here are some popular emojis people often use to make their comments seem less shitty.

🎉 😄 🙏 ❤️ 😍 👍 🤔 🙅‍♂

Symptom #3. Do you feel entitled?

Of course these people should make their code open source. Of course these people should implement the features you request them. Of course they should fix this bug ASAP because they don’t have anything better to do. Right?

Hate to break it to you but people in the open source community are real people. It may not seem like it, but they are. It’s very likely that these people have jobs, commitments, and other stuff to do. So don’t be surprised if they can’t fix that one bug you found right away or refuse to implement a very specific feature only a small percentage of users would use. That’s why Github has that little “Fork” button at the top right corner.

Prescription 💊

This one is hard. All I can tell you is that you aren’t entitled to anything. If you really want something, open up a pull request and ask nicely, pretty please.

To wrap up…

I just counted and this blog post contains 17 assholes. What I’ve said may have rubbed off in a wrong way for some of you and I apologize. But I felt the need to share this because some people just need the rude awakening; including me.

It’s been a year I started to really contribute to open source projects and I always catch myself being an asshole. It’s definitely not easy to come off as being asshole online but hey, you can at least try 😄.

Go test your tests in Go with go test

Mon, 28 May 2018 01:17:11 +0000

Today, we are going to talk about something that is boring… but necessary; tests.

But you are probably tired of reading blog posts that talk about “Why testing is important”, “Why your thing should have tests”, and “Top 5 reasons you should adopt test-driven development”. So, instead of writing about the usual “You need tests because it will blah your blah with blah because of blah”, I want to talk about something else; how to make writing tests not suck as much.

Here are some tips and tricks I picked up while writing tests for fac.

1. Current Testing Directory

Here is a fun fact; when you run go test for a package, the test binary will be run within the package being tested.

Allow me to demonstrate. Assume your project directory is setup like this

project
└── server
    ├── server.go
    └── server_test.go

And your server_test.go looks like this

package server

import (
	"os"
	"testing"
)

func TestCoolServerStuff(t *testing.T) {
	wd, _ := os.Getwd()
	t.Log(wd)
}

If you run this from your root project directory, you will get the following output

➜ pwd
/Users/mikechoi/src/go/src/github.com/mkchoi212/project

➜ go test -v
=== RUN   TestCoolServerStuff
--- PASS: TestCoolServerStuff (0.00s)
          server_test.go:10: github.com/mkchoi212/project/server
PASS
ok        github.com/mkchoi212/project/server        0.007s

Notice that the log says github.com/mkchoi212/project/server and not whatever pwd said.

2. testdata is ignored

According to this Go documentation,

Directory and file names that begin with “.” or “_” are ignored by the go tool, as are directories named “testdata”.

So, if you need mock files to test something - such as response.json for your networking functions - you can place it in package_directory/testdata/response.json. Now, you can easily load the mock files like so

func TestServerResponse(t *testing.T) {
    if json, err := os.Open("testdata/response.json"); err != nil {
        doStuffWithNetworkResponse(json)
        t.Log("🎉")
    }
}

Notice that we are able to simple say testdata/response.json because of #1.

3. testhelper

This is a simple concept but is very helpful when writing tests in Go. When writing code in Go, you probably have written thousands of lines of code that look like this

if data, err := doSomethingCool(); err != nil {
    doMoreCoolThingsHere(data)
}

The trouble is that this is what 80% of statements you are going to tests are going to look like. After all, you are testing if something either didn’t return an error, is equal to something, and or didn’t crap out. Eventually, your testsuite will get filled with if data, err := ....; err != nil statements. So, the brilliant solution to this is to make helper functions.

Instead of writing the code you saw previously with bunch of if-statements, you can now write the following.

func TestCoolThing(t *testing.T) {
    data, err := doSomethingCool()
    // Awesome
    testhelper.Ok(t, err)
    
    otherData, err := doSomethingAmazing()
    testhelper.Ok(t, err)

    // This is really useful as well
    testhelper.Equals(t, data, otherData)	
}

And if a test fails for some reason, the helper functions will print out the error messages in red and pin-point the location where the test failed.

3. go test tricks

Here are some additional tips and tricks you can use while using go test.

Test all packages in project directory

./... is the magic argument.

➜ go test
ok      github.com/mkchoi212/project              [no test files]

➜ go test ./...
ok      github.com/mkchoi212/project              [no test files]
ok      github.com/mkchoi212/project/server       0.012s
ok      github.com/mkchoi212/project/testhelper   [no test files]

Ignore package while testing

You might need this when you don’t necessarily need to test something or because you just want a higher code coverage percentage 😄

Notice testhelper is not being tested any more

➜ go test `go list ./... | grep -v 'testhelper'`
ok      github.com/mkchoi212/project              [no test files]
ok      github.com/mkchoi212/project/server       0.012s

Code coverage statistics

➜ go test --cover
PASS
coverage: 100.0% of statements
ok      github.com/mkchoi212/project/server  0.011s

Common Gotchas in Go

Mon, 01 Jan 2018 06:55:03 +0000

First thing is first. Happy New Years 🎉🎉

Now that’s out of the way, let’s talk about Go. I recently finished making my first real Go program. It’s called “Fix All Conflicts” or fac for short. It’s an easy-to-use console user interface for fixing git merge conflicts. I made it because I never found a merge tool that was intuitive enough to use.

The process was quite fun and I learned a lot about Go in the process. So, to wrap up my first official foray into Rob Pike’s mystical land of gophers, I decided to write down some of the common “Gotchas!” that any beginning Gopher - me - can run into.

Gophers can be quite aggressive sometimes.

⚠️ 1.) Range

The range function is one of the most commonly used functions in Go. Here’s a sample use case of the range function. Note that for some demented reason, we decided to make all the animals in the zoo have 999 legs.

package main

import "fmt"

type Animal struct {
	name string
	legs int
}

func main() {
	zoo := []Animal{
		Animal{"Dog", 4},
		Animal{"Chicken", 2},
		Animal{"Snail", 0},
	}

	fmt.Printf("-> Before update %v\n", zoo)

	for _, animal := range zoo {
		// 🚨 Oppps! `animal` is a copy of an element 😧
		animal.legs = 999
	}

	fmt.Printf("\n-> After update %v\n", zoo)
}

The above code looks innocent enough. However, you may be surprised to find that animals.legs = 999 didn’t do anything.

-> Before update [{Dog 4} {Chicken 2} {Snail 0}]
-> After update  [{Dog 4} {Chicken 2} {Snail 0}] 🚨🚨🚨 

Lesson

Value property of range (stored here as animal) is a copy of the value from zoo, not a pointer to the value in zoo.

The Fix

In order to modify an element within the array, we must change the element via its pointer.

for idx := range zoo {
  zoo[idx].legs = 999
}

This may look quite trivial but you may be surprised to find this as a one of the most common source of bugs; at least for me!

» Go playground #1 for you to play around in

⚠️ 2.) The … thingy

You may have used the … keyword in the C programming language to create a variadic function; variadic function is a function that takes a variable number or type of arguments.

In C, you have to successively call the va_arg macro in order to access the optional arguments. And if you use the variadic argument in any other way, the compiler will throw an error.

int add_em_up (int count,...) {
  ...
  va_start (ap, count);         /* Initialize the argument list */
  for (i = 0; i < count; i++)
      sum += va_arg(ap, int);   /* Get the next argument value */
  va_end (ap);                  /* Clean up */
  return sum
}

In Go however, things are similar but quite different at the same time. Here is a variadic function myFprint in Go. Notice how the variadic argument a is being used.

func myFprint(format string, a ...interface{}) {
	if len(a) == 0 {
		fmt.Printf(format)
	} else {
		// ⚠️ `a` should be `a...`
		fmt.Printf(format, a)
		// ✅
		fmt.Printf(format, a...)
	}
}

func main() {
	myFprint("%s : line %d\n", "file.txt", 49)
}

[file.txt %!s(int=49)] : line %!d(MISSING)
file.txt : line 49

You’d think that the compiler would throw an error here for using the variadic parameter a in a wrong way. But notice how fmt.Sprintf just used the first argument in a without throwing a fit.

Lesson

In Go, variadic parameters are converted to slices by the compiler

This means that the variadic argument a is in fact, just a slice. Because of this, the code below is completely valid.

// `a` is just a slice!
for _, elem := range a {
  fmt.Println(elem)
}

The Fix

Remember to type ALL THREE DOTS whenever using variadic parameters!

» Go playground #2 for you to play around in

⚠️ 3.) Slicing

If you have done your fair share of slicing in Python, you may remember that slicing in Python gives you a new list with just the references to the elements copied over. This property allows for code like this in Python.

a = [1, 2, 3]
b = a[:2]			# 👀 a completely new list!
b[0] = 999
>>> a
[1, 2, 3]
>>> b
[999, 2]

However if you try the same thing in Go, you get something else.

func main() {
	data := []int{1, 2, 3}
	slice := data[:2]
	slice[0] = 999

	fmt.Println(data)
	fmt.Println(slice)
}

[999 2 3]
[999 2]

Lesson

In Go, a slice shares the same backing array and capacity as the original. So if you change an element in the slice, the original contents are modified as well.

The Fix

If you want to get an independent slice, you have two options.

// Option #1
// appending elements to a nil slice
// `...` changes slice to arguments for the variadic function `append`
a := append([]int{}, data[:2]...)

// Option #1
// Create slice with length of 2
// copy(dest, src)
a := make([]int, 2)
copy(a, data[:2])

And according to StackOverflow, the append option is slightly faster than the make. + copy option!

» Go playground #3 for you to play around in

Hacker News thread 🤩

Things we can learn from Microsoft

Sat, 23 Dec 2017 06:22:11 +0000

Let me tell you something about me. I was obsessed with HackerNews for about three months. Not a single day went by where I didn’t check the front-page.

Anyways, during those three months, hundreds of articles went past my fingers. I admit I don’t remember all of them but there were few articles that lingered in the back of my head. And surprisingly, a big chunk of those articles had to do with Microsoft during its early days. So, this is me writing them down to see what I can learn from them.

So… here are three lessons we can all learn from Microsoft during the 1980’s.

Lesson #1. Optimize the most common operations

Before you quote Don Knuth, here is a story of how Microsoft Word became the most popular word processor in the world.

In 1983, PC Word 1.0 and Mac Word 1.0 shipped with a feature called “Piece Table”. The piece table wasn’t an official feature that was printed on the floppy disk but it was the data structure that enabled many of the listed features.

For example, it allowed for super fast copy and paste, undo and redo operations. You can go here to see how they were actually implemented but here is the TL;DR version of it.

Instead of storing text in the document as a single long string of characters, one can maintain a small set of records; a piece table. This table can then hold a collection of data that is only a few bytes long - a piece - that describes how a string is fragmented into pieces.

Although this sounds quite mundane now, super fast undo/redo and paste operations were like black magic to people in the 80’s. This is because back then, you had to go grab a cup of coffee and take a stroll around the park in your Reeboks while waiting for your word processor to finish copying and pasting a paragraph from the “American Psycho”. Nevertheless, people loved these features they allowed them to write without being interrupted and therefore save countless hours.

Later when Word 3.0 launched, Microsoft revolutionized the word processing industry once again with a feature called fast save. I won’t describe how they managed to implement fast save but I think that this feature is the best thing Microsoft has ever shipped… ever.

Lesson #2. Make it backwards compatible

Microsoft has shipped many versions of their Windows operating system but here’s a lesson we can all learn from them.

It takes only one program to sour an upgrade.

Now, allow me to elaborate.

Let’s say you are an IT manager of a company and you find out that if you upgrade to a new fancy version of the OS, program X the entire company uses won’t work anymore. You really want that one feature that comes with the new OS so you desperately make the call to the company that makes program X to request for an upgrade. But it turns out, the upgrade won’t be free. At this point, would you upgrade to the new OS?

Microsoft’s Setup/Upgrade team figured out that every single user had a “deal-breaker” program, a program that must run or they won’t upgrade. This is why Microsoft Windows has that one mysterious directory C:\WINDOWS\AppPatch that stores all the .dlls to support application backwards compatibility; this is why you can still play Sims 1 on your computer.

Lesson #3. A.B.C. Always Be Considerate

Excuse my poor attempt to reference Glengarry Glen Ross but the message still stands; Always Be Considerate! Unlike Alec Baldwin here, I am not saying you should be considerate to the people you are trying to sell houses to. Instead, you should be considerate to the end users of your software.

When Microsoft wanted to make a scripting language for Excel users, they started a project called Visual Basic for Applications. In the beginning, the developers had to decide whether if they wanted the language to be statically (strong) typed or dynamically (weak) typed. Personally, I am in the statically typed languages camp as I love using Swift and Golang. These two posts do a better job than me describing each side of the argument so I highly recommend you to read those when you have the time.

TL;DR The main gist of the argument is that statically typed languages allow you to find errors at compile time while dynamically typed languages allow you to find errors during runtime.

We could go on for days arguing over which one is better than the other and keep furiously typing away on our keyboards until our butterfly mechanism keys break. However, the end-user, who is most likely to be an accountant at a paper company like Dunder Mifflin, won’t care if it’s statically typed or dynamically typed. What that accountant cares about the most is whether if he can easily whip up a script for Excel that will let him automate repetitive tasks so he can go home to his kids a bit sooner.

If you decide to make the language statically typed, the intern that is in charge of writing the manual will have to describe to the accountant what a variable is and most importantly, what types are and why they are so important. Or you could make the language dynamically typed and let the accountant just start coding away immediately. Yes, the accountant will get runtime errors but he probably isn’t writing a program for the Apollo 11 lunar module. All the accountant wants to do is add up column A through Z.

You may have strong beliefs about a certain decision that has to be made in a project. However, are you being considerate of the user?

Taming the Feed

Fri, 15 Dec 2017 03:14:13 +0000

I don’t know about you or what other cool cats are doing nowadays, but I use RSS (Really Simple Syndication) to suck in all the content from the Internet. To get specific, I use Reeder as my primary RSS application and Instapaper as my goto save-for-later bucket.

During the summer of 2016, I became obsessed with HackerNews. In the beginning, it was nice because I was reading and absorbing anything and everything interesting that was going on the Internet. I was learning something new everyday and was becoming a better developer. In addition, I was up-to-date with the latest gossips and practically heard of every “new cool language/framework/testing tool”. However, this came with a price. I was checking HackerNews about 10-15 times a day. No article went by me unread. Every single article had that faint light gray color as they went past my fingers of fury. At a certain point, it seemed like I was reading more than I was coding.

Then school started again.

What used to be a morning ritual of checking HackerNews became impossible. If I was lucky, I got to check the feed once or twice a day. Even then, I would only be able to read one or two articles and save the rest into Instapaper. And eventually, Instapaper became a place where essays and blog posts go to die and rot in a pile of their own digital waste.

RSS was even worse. I had subscribed to about 30+ RSS sources and was getting up to 60 new articles per day. After about a week into school, I didn’t even try to catch up on these. In fact, Reeder ended up losing its spot on my Dock.

I bet 5000 unread articles is some sort of new record. I also bet 5000 is the highest number of unread articles Feedly will let you have.

It’s Winter Break now and it’s about 55 degrees in Texas. I’m currently sitting at a cafe drinking a latte that is way too sweet and trying to fix the mess I have found myself in. To do this, I wrote myself a little prescription. If you are experiencing the same symptoms as I am, I recommend you do the same.

Rules of Engagement with articles from the Interweb/HackerNews

1. Read at least 5 articles from my saved Instapaper feed every day

DO NOT ADD NEW ARTICLES UNTIL THE RED BUBBLE THINGY REACHES ZERO!

2. Limit reading HackerNews to only TWICE a day

3. Only keep 4-5 most interesting subscriptions in Reeder’s RSS feed

I know there are lots of interesting articles out there but you will never get to all of them.

Monoids deployed

Sat, 23 Sep 2017 04:34:45 +0000

First of all, an explanation of the title is in order. I used the word “deployed” just because it kind of rhymed with “Monoid”. It’s probably a better choice than what I was originally going to use; “Monoids on Steroids”.

Anyways, this post will be an attempt to explain what monoids are, why they are useful and most importantly, how they can be used. We will also build a simple shapes library in Haskell and Swift as an example.

To start off with, here is an example of a monoid. Ready?

+ 0 = 1
+ 1 = 1
+ (2 + 3) = 6
(1 + 2) + 3 = 6

If you understand these highly complex mathematical equations, you understand what monoids are. Congratulations 🎉🎉🎉.

Formal Definition

Mathematical

A monoid is a tuple (M, op, e) where

M is a set of element
op is an associative binary operation on two elements M, returning a new element of M
e is an element of M, neutral for op on both left and right side

So for example, the above addition operator would form the following tuple of (Int, +, 0)

Statically typed languages

Since we are programmers, let us translate the above definition to code. A monoid consists of a type T and a function f where

`f` takes an instance of `T` and returns an instance of `T`

func foobar(_ in: String, _in2: String) -> String

The above statement says that a binary operation of monoids takes two elements of type T and will always return T. The input type is same as the output type. This property is very important as it will allows us to chain operations indefinitely.

`f` is associative

Associative property is when f(c, f(a, b)) == f(f(c, a), b) holds true.

In other words, we are looking for the situation where something like 1 + (2 + 3) == (1 + 2) + 3 makes sense. This allows us to not worry about the ordering when we compose functions. We will see examples of this later.

`f` has a neutral element `e` where `f(e, a) == f(a, e)`

We are looking for e that allows foobar(NEUTRAL_ELEMENT, 5) == foobar(5, NEUTRAL_ELEMENT)

For example, 0 is the neutral element for the addition operator since 0 + 3 == 3 + 0

Monoids everywhere

By now, you hopefully have a sense of what monoids are. And the funny thing is, you probably have been using monoids all along without evening knowing it. Here are some examples of commonly used monoids that are unfortuantley not acknowledged as monoids most of the time.

Integers under addition with neutral element zero
Integers under multiplication with neutral element one
Sequential containers under concatenation (String, List)
Associative containers under union (map, set)

But why should I care?

Th idea of monoids come from the realms of functional programming where the ultimate goal is to come up with simple abstractions that can later be composed to create complex behaviors. Monoids are a great representation of the FP mindset as it gives us a way to build complexity out of simplicity. This means that before you dive into a problem, you can start by formulating a very simple idea. Once you solidify this idea, you can then use it to build complex objects that will eventually solve your problem.

ASCII Art Generator

To see how monoids can be used, we will create a library with power enough abstractions that will allows us to create some interesting ASCII art. Our library will mainly deal with creating geometric shapes.¹ As we go through the code, I will demonstrate each example in Haskell and then follow up with Swift.

Abstracting a “Shape”

Here, we will define a shape as a function that takes a coordinate point as an input and returns a boolean as an output. The idea is simple; you ask the function if the point (x, y) is contained in the shape and, if true is returned, we then know it’s part of the shape.

To define a shape, we will make a Shape type with the function - isInShape - I just described above. We will also define some typealiases to make life easier. Notice that we are using a generic struct. This is so that we can use not only Coord2D but also Coord3D, Coord4D in the future.

newtype Shape coord = Shape {	  
  isInShape :: coord -> Bool	
}
type Coord2D = (Double, Double)	
type Shape2D = Shape Coord2D

struct Shape<C> {
  let isInShape : (C) -> (Bool)
}
typealias Coord2D = (Double, Double)
typealias Shape2D = Shape<Coord2D>

Because we are describing shapes as functions, we can easily define the complement of a shape. For example, we can make the function outside. All it would have to do is negate the predicate of the input shape.

outside :: Shape coord -> Shape coord
outside s = Shape (not . isInShape s)

// Thanks to u/thisischemistry, code is now more understandable and self-documenting
extension Shape {
  func outside() -> Shape {
    let notInOriginalShape = { coord in
      !(self.isInShape(coord))
    }
    return Shape(isInShape: notInOriginalShape)
  }
}

Creating Shapes

To define a shape, we need to specify the isInShape function to describe whether a point belongs in the shape or not. Here’s how we would define a disk.

disk :: Coord2D -> Radius -> Shape2D	
disk center radius =
	Shape $ \coord -> euclidianDistance center coord <= radius

extension Shape {
  init(center: Coord2D, radius: Double) {
    isInShape = { coord in
      guard let coord = coord as? Coord2D else { fatalError("Center must be a 2D point") }
      return euclidianDistance(p1: center, p2: coord) < radius
    }
  }
}

Now, we can experiment and have some fun with some sample coordinates

let disk = Shape<Coord2D>(center: (10.0, 10.0), radius: 8.00)
disk.isInShape((13.0, 13.0))
> true

And with a simple loop, we can print the disk out. The output looks a bit off because the line widths are larger than the character spacings. But hey, still pretty cool, eh?

      *******                                     
     ***********                                   
    *************                                  
    *************                                  
   ***************                                 
   ***************                                 
   ***************                                 
   ***************                                 
   ***************                                 
   ***************                                 
   ***************                                 
    *************                                  
    *************                                  
     ***********                                   
       *******                                     

Complex shapes

Now that we have our basic idea down, let’s stat complicating things. And since we are in the realm of FP, what would this post be without some composition!? Let’s try to build cooler shapes via composition.

We can first start by defining the intersect function which defines a new shape within the region of intersection.

intersect :: Shape coord -> Shape coord -> Shape coord	
intersect s1 s2 =	  
	Shape $ \coord -> isInShape s1 coord && isInShape s2 coord

extension Shape {
  func intersect(_ s1: Shape) -> Shape { 
    return Shape { coord in
      self.isInShape(coord) && s1.isInShape(coord)
    }
}
  
let disk = Shape<Coord2D>(center: (10.0, 10.0), radius: 8.00)
let square = Shape<Coord2D>(origin: (7.0, 7.0), width: 6, height: 6)
let ring = disk.intersect(square.outside())

Printing ring yields the below result

      ********                                     
     ***********                                   
    *************                                  
    *************                                  
   ****       ****                                 
   ****       ****                                 
   ****       ****                                 
   ****       ****                                 
   ****       ****                                 
   ****       ****                                 
   ****       ****                                 
    *************                                  
    *************                                  
     ***********                                   
       *******      

Kind of looks like those rings from Sonic, eh?

Wrapping Up

I hope the shapes example demonstrated how great monoids are when it comes to composition and abstraction. Personally, I have constantly failed to recognize the fact that I have been using something people have discovered, named and implemented. I try to recognize them and utilize them when I code but it can be very hard to do so.

Monoids are a great example of this. It’s something functional programmers use all the time but is something that never gets called out explicitly in imperative programming languages. I think this is a shame because once you recognize the fact that something is a monoid, you get access to some incredible perspectives from where you can look at your code.

Anyways, the one thing I wish you got away from this post is that after recognizing a good use case for a monoid, you can start with something really simple. Then, as the logic grows, you can build something very complex on top of a very firm foundation.

Conal Elliott ↩

Reentrant and Threadsafe Code

Sun, 17 Sep 2017 04:28:03 +0000

If you have programmed in C, you probably have typed man strtok on the terminal. Ah yes, the infmaous strtok function. The internet seems to really hate it but you decide to give the function a chance and try to read through the man page. Just in case none of what I said applies to you, here’s the first sentence in the description section of the man page.

This interface is obsoleted by strsep(3)

Uh ok… Even the folks at FreeBSD seem to hate it so much that they just completely replaced it with a different function. But you keep reading to see what’s so bad about it and you come across the following sentence.

The strtok_r() function is a reentrant version of strtok()

At this point, you could asking “what does it mean by a function to be reentrant?”. If you know the answer to this question, you should stop reading this post and move on to a different post.

For those who don’t know what reentrant functions are, this is how the man page describes it.

The context pointer last must be provided on each call. The strtok_r() function may also be used to nest two parsing loops within one another, as long as separate context pointers are used.

Does it mean that the reentrant function is some how better than the non-reentrant version because it can be used to nest two parsing loops? Well, before we can answer that question, we first need to know what makes a function reentrant than its non-reentrant counterparts.

Threadsafe Code

From the word “reentrant”, you can kind of guess that it is probably going to be some piece of code that is going to be re-entered. And you would be right. Reentrant code is mostly used in multithreaded programs to maintain its integrity and keep programmers from going insane from mysterious race conditions and pure hell. And now, you could asking “Hey! Don’t we already have a word for that? That kind of code is called threadsafe!” And , you would be right, once again. So what’s the fricking difference???

Reentrant Code VS. Threadsafe Code

Let’s do some definitions.

Thread safe code is one that can be performed from multiple threads safely, even if the calls happen simultaneously on multiple threads.

Reentrant code is one that can be entered by another actor before an earlier invocation has finished, without affecting the path the first action would have taken through the code.

Did you catch the difference? Thread safe code means you can call the function on multiple threads. Reentrant code means that you can do all the things thread safe code can do but also gurantee safety even if you call the same function within the same thread.

So, reentrant code can be thread safe but thread safe code can’t be reentrant? Not necessarily… Before we complicate things, let’s go and look at some code.

Show me the code

Just like how most books do it, we will first start off with bad code. Then, we will slowly make it better, worse again, and eventually make it immune to any convoluted multithreaded code.¹

Reentrant ❌ | Thread-safe ❌

int t;

void swap(int *x, int *y) {
  t = *x;
  *x = *y;
  // `my_func()` could be called here
  *y = t;
}

void my_func() {
  int x = 1, y = 2;
  swap(&x, &y);
}

❌ Thread-safe because
- Global variable t is constantly mutating within swap
❌ Reentrant because
- Global varaible t
- my_func() could be called while swap() is running in the same context. If so, value of t would be unpredictable

This code can easily be made to be thread-safe though. All we need to do is make t a thread local variable.

Reentrant ❌ | Thread-safe ✅

#include <threads.h>
// `t` is now local to each thread
thread_local int t;

void swap(int *x, int *y) {
  t = *x;
  *x = *y;
  // `my_func()` could be called here
  *y = t;
}

void my_func() {
  int x = 1, y = 2;
  swap(&x, &y);
}

✅ Thread-safe because
Variable t is local to each thread
❌ Reentrant because
Threads are safe from each other but if multiple calls to my_func() happen within a single thread, value of t is still unpredictable

Reentrant ✅ | Thread-safe ❌

No one would do this in real life but for the sake of example, here’s some very convoluted code.

int t;

void swap(int *x, int *y) {
  int s;
  // save global variable
  s = t;
  t = *x;
  *x = *y;

  // `my_func()` could be called here
  *y = t;
  // restore global variable
  t = s;
}

void my_func() {
  int x = 1, y = 2;
  swap(&x, &y);
}

❌ Thread-safe because
- Global data can’t be guaranteed to be the same at all times
✅ Reentrant because
- Funky but global data is the same when the program enters and or leaves swap

Reentrant ✅ | Thread-safe ✅

The solution was just staring at us from the beginning. That one professor from CPSC 101 was right all along; global variables are bad.

void swap(int *x, int *y) {
  int t = *x;
  *x = *y;

  // `my_func()` could be called here
  *y = t;
}

void my_func() {
  int x = 1, y = 2;
  swap(&x, &y);
}

✅ Thread-safe and ✅ reentrant because
t is now allocated on the stack

Rules of Thumb

To write a block of code that is reentrant, you should adhere to the following rules of thumb¹

Don’t use global or static variables
Don’t let it modify its own code
Don’t call other non-entrant functions

Back to strtok

So, let’s apply what we learned here to strtok. Usually, when we use strtok, we do the following²

token[0] = strtok(string, separators);
i = 0;
do {
  i++;
  token[i] = strtok(NULL, separators);
} while (token[i] != NULL);

This is completely reasonable code besides the fact that it is using strtok and is neither reentrant nor thread safe. However, strtok_r can come in and save the day with only minor changes to the code

char *pointer;
...
token[0] = strtok_r(string, separators, &pointer);
i = 0;
do {
  i++;
  token[i] = strtok_r(NULL, separators, &pointer);
} while (token[i] != NULL);

Now, thanks to the reentrant version of the strtok, this code block can now be used in multithreaded programs.

So…

the next time you are stuck in constant deadlock, data mutating, blood boiling mutiprogramming hell, first ask yourself, “Hey, is this code reentrant and or threadsafe?”

0xDEADBEEF

Material Objects I Enjoyed in 2025

Small Coffee Cups

Contax T2

My Glasses

1461, Made in England

The Coffee Scoop

American Beaujolais

A Matter of Concrete

Glow-in-the-Dark Nalgene Bottle

The Weekender Bag

The Perfect White T-shirt

Man in the Arena

Xcode Auto Generated Interfaces

Look closely 👓

Initializers

Functions

enums

Wrapping Up

Open-source self-diagnostics

Symptom #1. Do you use words such as “simply” or “just”?

Prescription 💊

Symptom #2. Do you give out orders?

Prescription 💊

Symptom #3. Do you feel entitled?

Prescription 💊

To wrap up…

Go test your tests in Go with go test

1. Current Testing Directory

2. testdata is ignored

3. testhelper

3. go test tricks

Test all packages in project directory

Ignore package while testing

Code coverage statistics

Common Gotchas in Go

⚠️ 1.) Range

Lesson

The Fix

⚠️ 2.) The … thingy

Lesson

The Fix

⚠️ 3.) Slicing

Lesson

The Fix

Things we can learn from Microsoft

Lesson #1. Optimize the most common operations

Lesson #2. Make it backwards compatible

Lesson #3. A.B.C. Always Be Considerate

Taming the Feed

Rules of Engagement with articles from the Interweb/HackerNews

1. Read at least 5 articles from my saved Instapaper feed every day

2. Limit reading HackerNews to only TWICE a day

3. Only keep 4-5 most interesting subscriptions in Reeder’s RSS feed

Monoids deployed

Formal Definition

Mathematical

Statically typed languages

f takes an instance of T and returns an instance of T

f is associative

f has a neutral element e where f(e, a) == f(a, e)

Monoids everywhere

But why should I care?

ASCII Art Generator

Abstracting a “Shape”

Creating Shapes

Complex shapes

Wrapping Up

Reentrant and Threadsafe Code

Threadsafe Code

Reentrant Code VS. Threadsafe Code

Show me the code

Reentrant ❌ | Thread-safe ❌

Reentrant ❌ | Thread-safe ✅

Reentrant ✅ | Thread-safe ❌

Reentrant ✅ | Thread-safe ✅

Rules of Thumb

Back to strtok

So…

`f` takes an instance of `T` and returns an instance of `T`

`f` is associative

`f` has a neutral element `e` where `f(e, a) == f(a, e)`