So does Birkey Consulting:

I love NixOS because it fits especially well with the way I work in the current LLM coding era. Tools are changing very quickly. Coding agents often need very specific versions of utilities, compilers and runtimes. They need to install something, use it, throw it away, try another version and keep going without turning my PC into a garbage dump of conflicting state. Nix fits that model naturally. If I tell a coding agent that I use Nix, it is usually clever enough to reach for nix shell or nix develop to bring the needed tool into an isolated environment and execute it there. That is especially handy because Nix treats tooling as a declared input instead of an accidental side effect on the system.

One wrinkle I've found is that Codex will get tripped up if I add a shell.nix file after the session has started. My theory: Codex gets the $PATH value at start and has no way to update it later. Not a huge deal to exit the session, start a new one, and /resume the conversation.

Also, the Nix language is like if jsonnet got hit by an even more function-oriented truck. LLMs make this suck less though since they're great at writing Nix!

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = [
    pkgs.go
    pkgs.gopls
    pkgs.nodejs
  ];

  hardeningDisable = [ "fortify" ];

  shellHook = ''
    DIRECTORY_NAME="/tmp/$(basename "$PWD")"
    mkdir -p $DIRECTORY_NAME/go-cache $DIRECTORY_NAME/go $DIRECTORY_NAME/npm
    export GOPATH=$DIRECTORY_NAME/go
    export GOCACHE=$DIRECTORY_NAME/go-cache
    export NODE_PATH=$DIRECTORY_NAME/npm
    export NPM_CONFIG_PREFIX=$NODE_PATH
    export PATH=$DIRECTORY_NAME/go/bin:$PATH:$NODE_PATH/bin
  '';
}

The goal of shell.nix is to give every project it's own shell where all the needed tools are available and isolate each project from itself, e.g. one project can use a different version of node.

I've settled on the convention of /tmp/<project-dir-name> as the location for "language" or "runtime" dependencies. Meaning, nix handles bringing in node but then node wants to install things too. /tmp is a nice place because I don't care where that stuff goes I just don't want it to collide with other things.

Any iPad + a keyboard case makes zero sense compared to the Neo.

All the iPad's capabilities (M-series CPU, OLED screen, premium everything) are wasted on iPadOS. iPad is also needlessly stuck with a single USB-C port. Is the Neo's second port good? No! But in a pinch it's better than no port.

The A18 Pro is great, already compiled a few Xcode projects, listened to multiple sources of audio at once, and even managed my clipboard.

Oh, and the Neo actually goes to sleep, like real sleep. No dead battery issues like iPadOS.

It's the cheapest, most repairable, and smallest Mac. Win, win, win.

It's actually pretty straightforward, utilize fetchTarball to pull in nixpkgs based on a commit where the version was present sometime in the past. You can mix that import in with regular/"current" packages with no issue like so:

{ pkgs ? import <nixpkgs> {} }:

let oldGo = import (builtins.fetchTarball {
    url = "https://github.com/NixOS/nixpkgs/archive/33c51330782cb486764eb598d5907b43dc87b4c2.tar.gz";
    sha256 = "sha256:0nflmpfp3pk704vhlvlgh5vgwl8qciqi18mcpl32k79qjziwmih8";
    }) {};
in 

pkgs.mkShell {
  buildInputs = [
    oldGo.go_1_20
    pkgs.gopls
    pkgs.nodejs_18
  ];
  
  hardeningDisable = [ "fortify" ];

  shellHook = ''
    mkdir -p .go .npm
    export GOPATH=$PWD/.go
    export NODE_PATH=$PWD/.npm
    export NPM_CONFIG_PREFIX=$NODE_PATH
    export PATH=$PWD/.yarn/sdks/typescript/bin:$PWD/.go/bin:$PATH:$NODE_PATH/bin
  '';
}

Notice I can reference the "nixpkgs" tarball/snapshot, oldGo, and pull in the version of Go I need?! nixpkgs is such a treasure trove of software, it's absolutely incredible!

PR Kudos

I created this script to help me give better kudos to folks in our retro meeting. When I provide a Github team name as an argument, it displays all PRs from members of that team. What I really like is that it only shows PRs from the last two weeks, which gives me a nice overview of recent activity.

#!/bin/bash

start=$(date -d "2 weeks ago" +%Y-%m-%d)
end=$(date +%Y-%m-%d)

details=$(gh api /orgs/grafana/teams/$1 | jq -r '"\(.id),\(.organization.id)"')
teamId=$(echo ${details} | cut -d , -f 1)
orgId=$(echo ${details} | cut -d , -f 2)

gh api "organizations/${orgId}/team/${teamId}/members" | \
  jq -r '.[] | .login' | \
  xargs -I % gh search prs --author=% --created="${start}..${end}" \
  --json="state,repository,url,title,updatedAt,author" --template '{{range .}}{{tablerow (.author.login | autocolor "green") (hyperlink .url .title) (.repository.name | autocolor "blue") (.state | autocolor "red") (timeago .updatedAt)}}{{end}}
{{tablerender}}'

Notification OCD

The second script focuses on managing notifications related to pull requests and issues. I usually find that about one-third of my notifications are for merged PRs, PRs created by bots, or closed Issues. I don't care about these types of events. With this script, I can mark those notifications as done, which reduces clutter in my GitHub notifications and helps me see important updates. As I mentioned above, one cool feature of the api subcommand is that it allows me to consume all possible pages of a response using the --paginate flag, eliminating the need for a loop + token field dance!

#!/bin/bash
declare -A typeLookup
typeLookup["PullRequest"]="pull"
typeLookup["Issue"]="issues"

resp=$(gh api /notifications --paginate | jq -r '.[] | select(.subject.type == "PullRequest" or .subject.type == "Issue") | "\(.repository.full_name),\(.subject.url),\(.id),\(.subject.type)"')

for x in $resp; do
  name=$(echo "${x}" | cut -d ',' -f 1)
  id=$(echo "${x}" | cut -d ',' -f 3)
  number=$(basename $(echo "${x}" | cut -d ',' -f 2))
  ofType=$(echo "${x}" | cut -d ',' -f 4)
  urlType=$(echo ${typeLookup["${ofType}"]})
  isBot="false"

  if [ "${ofType}" == "PullRequest" ]; then
    isMerged=$(gh pr view --repo "${name}" "${number}" --json closed | jq -r .closed)
    isBot=$(gh pr view --repo "${name}" "${number}" --json author | jq -r .author.is_bot)
  fi

  if [ "${ofType}" == "Issue" ]; then
    isMerged=$(gh issue view --repo "${name}" "${number}" --json closed | jq -r .closed)
  fi

  if [ "${isMerged}" == "true" ] || [ "${isBot}" == "true" ]; then
    echo "marking https://github.com/${name}/${urlType}/${number} as done..."
    gh api -X PATCH "/notifications/threads/${id}"
  fi
done

Twitter and Reddit were both social websites that are/were terrible without a lot of cultivation and effort, but over the years I had shaped my experience on those services to be pretty good thanks in large part to Apollo and Tweetbot being such powerful tools.

Ironically the only social web thing I still use (outside of Instagram) is RSS. I will probably spin up a Mastodon instance here eventually but for now I've subscribed to folks via Mastodon's RSS support and it's good enough for now.

I guess I just wanted to give a shout out to the devs of Apollo and Tweetbot: thank you for making such great apps, I will miss them.

The original inspiration for this idea came from Simon Willison’s work with Datasette Lite. However, compiling Grafana as a WASM binary proved difficult with existing build constraints. After spending some time trying to get that to work I changed course a bit and instead focused on compiling a basic go HTTP server as a WASM module. The new goal being to have a proof of concept that bundled the HTTP server as a WASM binary and intercepted any clicked links on the page and finally passed those links to be resolved by the go server in WASM.

I used a Web Worker to interact with the WASM binary. This frees up the main thread of the browser. To put the WASM binary into the worker I loaded the binary and sent a message that contained the binary as a WebAssembly.Module.

The Web Worker can then call any go functions that have been exposed via FuncOf. Once the go function returns data, the worker posts that response back to the main thread via another message.

let module;
importScripts("wasm_exec.js")
go = new Go();

self.onmessage = async (e) => {
  if (e.data.type === "module") {
    module = e.data.module;
    return;
  }

  if (module) {
    console.log('Message received: ', e.data.path);
    const instance = await WebAssembly.instantiate(module, go.importObject);
    go.run(instance);
    postMessage(parsePath(e.data.path)); // parsePath is exposed via FuncOf
  }
}

Sidenote: I wish go could use the same pragma syntax tinygo uses to expose functions instead of the verbose FuncOf. There's an issue but it has been open since 2018.

Obviously, there is no localhost to listen on in a WASM environment. To get around that I created a bare bones ResponseWriter and used that with the Request to run the Handler’s ServeHTTP function which consults the routes that are defined and runs the matching handler code. This allowed me to use a build constraint (setup.go and setup_js.go) and keep my HTTP server functioning normally when run from a terminal but then also worked when run in a WASM context. Here's what those two files look like:

setup

//go:build !js
// +build !js

package main

import (
    "fmt"
    "net/http"
)

func setup() {
    s := NewServer()
    err := http.ListenAndServe(":9001", s.mux)
    if err != nil {
        fmt.Println("error: ", err)
    }
}

setup_js

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "net/http"
    "syscall/js"
)

type ResponseWriter struct {
    Body *bytes.Buffer
}

func (r ResponseWriter) Header() http.Header {
    return make(http.Header)
}

func (r ResponseWriter) Write(buf []byte) (int, error) {
    if r.Body != nil {
        r.Body.Write(buf)
    }
    return len(buf), nil
}

func (r ResponseWriter) WriteHeader(statusCode int) {}

func createWriter() ResponseWriter {
    return ResponseWriter{
        Body: new(bytes.Buffer),
    }
}

func parsePath(this js.Value, args []js.Value) interface{} {
    fmt.Println("args: ", args)
    server := NewServer()
    path := args[0].String()
    req, err := http.NewRequest(http.MethodGet, path, nil)

    if err != nil {
        fmt.Println("request error: ", err)
    }

    h, p := server.mux.Handler(req)

    fmt.Println("pattern: ", p)

    w := createWriter()

    h.ServeHTTP(w, req)

    b, err := ioutil.ReadAll(w.Body)

    if err != nil {
        fmt.Println("ioutil error: ", err)
    }

    return string(b)
}

func setup() {
    js.Global().Set("parsePath", js.FuncOf(parsePath))
}

Conclusions

The PoC worked! It's pretty slick to see a HTTP server running in WASM return back the correct data when a link is clicked. However, in my opinion, WASM continues to be a "solution in search of a problem". Yes it's incredibly cool technology but so are the JS engines in Chrome, Firefox, and Safari. The sheer amount of money and engineering time being spent on making JS fast is a race no other technology can win at the moment.

That said, Go seems to have done decent work at providing the necessary pieces to make compiling to WASM not awful.

Honestly, the thing that surprised and impressed me the most was working with Web Workers. They are seriously useful and seem to "just work".

Links that helped me out along the way

• Simon Willison’s post about Datasette Lite
• Philippe Charrière's post
• Roman Romadin's post

Some history

The first computer I ever purchased was the 12" Powerbook G4. Since that Powerbook I've always had laptops as my main machines (desktop gaming PC not withstanding). Remote working the last few years has made me realize that the portability of a laptop is largely wasted since I only travel a handful of times a year and yet I live with the downsides of a laptop the rest of the time. So, last year I started thinking about a desktop machine for my primary workstation. A desktop is appealing for a handful of reasons:

• More powerful CPUs
• More expansion capabilities
• More durable

The options

The Mac Studio was recently released to much fanfare and was really intriguing to me. However, when I started considering it I only had about a week to 10 days before my start date at Grafana and I couldn't wait the quoted 4-6 weeks delivery time for a Mac Studio with 32GB of RAM.

I was also pretty unwilling to leave my comfy NixOS install + i3. Michael Stapelberg's latest post about his new workstation proved timely and convinced me to give the new Intel Alder Lake CPUs a shot.

Apple's M1 family of chips deliver incredible performance per watt but I wasn't as concered about the power usage given this was a desktop machine not a laptop. I was however focused on at least matching the M1 chips in single-threaded performance since a good chunk of my development work (Node, build tools, etc) are still single-threaded. I ended up with the Intel i5-12600k and I really couldn't be happier. Here's the full parts list:

XMP issues

I ran into the same memory XMP issues that Michael mentions in his post so I disabled the XMP profile and the system passed the "Coding Horror burn in tests" with flying colors.

Cooling

I mounted the 140mm fan to the bottom of the case as intake and the CPU cooler is of course positioned as intake as well. Hot air rises out the top of the case quite well. During the prime95 torture test the CPU never got over 78°C and I couldn't ever hear either fan. I run both fans in the "silent profile" in the BIOS and I use Noctua's adapters to lower the voltage even more. Now the only fan I could hear during max load was the PSU fan which doesn't spin at all under low to medium loads but under high load it kicks on. Day to day it's hardly on so the system is dead quiet most of the time.

Case

I absolutely love the Cerberus case. It's Mini-ATX but still super compact and fits on my desk quite well. All the panels are solid metal and the way all the panels pop off is really really nice. I opted for the handle mount on the top and the internal PSU moutning.

Linux

NixOS installed just fine. I'm runing the 5.17 kernel because Alder Lake needs a newer kernel for it's graphics and CPU scheduler (coming soon?). I have WiFi and Bluetooh disabled in the BIOS since everything is hard-wired to the machine.

Verdict

This build has proven quite comfortable over the few weeks I've used it. I love that I have 2 free RAM slots if I ever feel the need for more RAM. I also love that I have 3 remaining Nvme slots on the motherboard for additional solid state storage in the future.

Now, I know it can be problematic to think about work like your (extended) family but when you work at the same place through your twenties and early thirties, have 3 different apartments, buy a house, and have two kids it’s impossible not to view that place differently. I can confidently say Sparkbox changed my life. The team there will always have a special place in my heart.

deep breath

So where to? Well, I’m super stoked to be joining Grafana as a Senior Software Engineer on their Cloud Data team! I’m looking forward to writing more Go, solving new problems, and learning from the stellar folks there.

Here we go…

It's been 5 years since I wrote "Thirty". So now I have to come up with 35 things as I turned 35 yesterday. If anything from Thirty is grossly wrong or really interesting I'll update it at the same number eh?

Let's go...

1. I still don't have it figured out, but this isn't such a shock anymore.
2. Building a house is more scary.
3. Minivans are awesome.
4. Expecting a third kid is not nearly as scary as expecting the first.
5. COVID sucked.
6. Modern medicine is pretty cool actually.
7. More stuff hurts, still just as healthy.
8. Dishwashers aren't really as scary to repair as they seem (but that doesn't mean you won't lose your mind fixing one).
9. The feeling you get as a parent when your kid gets hurt is impossible to describe.
10. Being knocked out from a crazy car accident is also no fun.
11. Carseats are magic.
12. I've accepted that the music I liked in 2010 is going to be the music I'll like forever.
13. Thanks to the internet there is an endless stream of new music that is at home with music from 2010 or even 2000 (Underoath just released a new album for crying out loud).
14. Open source software is incredible.
15. The thrill from in-progress software working for the first time will never get old for me.
16. Feedback loops are important in every area of life not just software.
17. The year of Linux on the desktop is a moving target.
18. RSS will never die.
19. Mechanical keyboards are a refreshing change and I'm not sure why.
20. The Aeropress is still incredible.
21. Computers were a mistake.
22. Computers are a miracle.
23. The Three-Body Problem trilogy continues to knock around in my brain months after finishing it.
24. Watching your child accomplish something for the first time that they've been working on is a feeling unlike any other.
25. I've realized I learn best by doing, I need to get better at accounting for the bumps along the way.
26. I write things down to remember them later not to look them up later which means most note systems are not worth the trouble for me.
27. Life will be shallow if you only hang out with people like you.
28. Anything is possible on an infinite timescale the trick is figuring out what do with finite time.
29. RIP Rdio.
30. Never pass on an opportunity to twirl your kids around when they're small. They get big fast.
31. Hanlon's razor explains most of social media.
32. If you work at a desk all day you owe it to yourself to remove as much Bluetooth from that setup as possible.
33. None of your peers has it all figured out. Ask them "dumb" questions.
34. Properly evaluating risks when your kids are involved is hard.
35. Keep a sweatshirt handy by your bed when your kids are young, getting up at 2am in the winter is cold.

❤️ you Christi

libvirtd.qemu = {
  package = pkgs.qemu_kvm;
  runAsRoot = true;
  swtpm.enable = true;
  ovmf = {
    enable = true;
    package = (pkgs.OVMFFull.override {
      secureBoot = true;
      tpmSupport = true;
    });
  };
};

The most important bit is the pkgs.OVMFFull.override section where you must specify tpmSupport and secureBoot as true.

In virt-manager you'll need to add "new hardware" and select TPM v2.0. Here's the relevant XML from my config:

<tpm model="tpm-crb">
  <backend type="emulator" version="2.0"/>
</tpm>

With the above settings you should be able to go through the Windows 11 installer and get the machine up and running as a KVM guest.

Stretch goal: nested virtualization

If you want to use Docker or WSL 2 inside KVM you'll need to enable "nested virtualization" in virt-manager. I couldn't figure this out until I found this great answer on superuser.

My original CPU config XML looked like this:

<cpu mode="host-model" check="partial">
  <topology sockets="1" dies="1" cores="2" threads="4"/>
</cpu>

The new XML looks like this:

<cpu mode="custom" match="exact" check="partial">
  <model fallback="allow">Skylake-Client-noTSX-IBRS</model>
  <topology sockets="1" dies="1" cores="2" threads="4"/>
  <feature policy="disable" name="hypervisor"/>
  <feature policy="require" name="vmx"/>
</cpu>

With this applied I could install WSL2 and get Docker Desktop for Windows installed and running.

I prefer the POSIX shell because it's the default on most unix-y system. If I have to be sure if the shell is installed on the target system (like bash or zsh) I'd rather just use a higher-level scripting language like node or ruby where the same requirement exists.

Arrays

Psych! There aren't any arrays. Bash has arrays but POSIX does not. If I need an array structure I can use a space-separated string (or another delimiter if you've set $IFS) as the data structure, e.g. PLATFORMS="arm64-darwin amd64-linux amd64-darwin". Now I can loop over the variable using a for loop:

PLATFORMS="arm64-darwin amd64-linux amd64-darwin"

for PLATFORM in ${PLATFORMS}; do
  # GOOS=FOO GOARCH=BAR go build ...
done

Or I can take the lack of arrays as a signal I should stop writing a shell script and reach for a language that has the concept of arrays to solve my problem.

Conditional "flags"

I often forget the various flags one can use in a conditional (aka test/if) statement. Here's the documentation and here are a few of my favorites:

• -n tests if the string is non-zero, e.g.

if [ -n "${UPLOAD_URL}" ]; then
    upload_file "${PLATFORM}"
fi

• -z the opposite of -n.
• -f tests if the pathname resolves to a file.

Functions and args

• Functions must be declared before they are invoked.
• Functions look like:

someFunc() {
  echo "a func!"
}

• There is no syntax for functions accepting args instead they are mapped to $n. $@ is all the args.

upload_file() {
    NAME=$1

    zip "${NAME}.zip" "${NAME}"
    curl -H "Accept: application/vnd.github.v3+json" \
         -H "Authorization: Bearer ${GITHUB_TOKEN}" \
         -H "Content-Type: application/zip" \
         --data-binary "@${NAME}.zip" \
         "${UPLOAD_URL}?name=${NAME}.zip"
}

upload_file "${PLATFORM}"

Use shellcheck

This is just preference but I really love using shellcheck to avoid any footguns and enforce a consistent style with my shell scripts. I typically invoke it like this: shellcheck -o all script-name.sh.

Here's a random assortment of links and miscellaneous updates on things.

autofs

autofs is a cool utility that watches a specific directory path and when a program tries to read or write to that path it mounts a filesystem at that location. I'm using this to auto mount my NAS via SMB for mpd. With autofs in place I can run mpd locally (in a "satellite setup") and have its music_directory point to a path managed by autofs.

One thing that was helpful getting the configuration right was testing autofs by running automount -f -v directly which puts it in the foreground and gives verbose output.

The two files I configured were auto.master.d/foo.autofs and auto.foo.

• foo.autofs contains one line: /- /etc/auto.foo
• auto.foo contains one line as well: /foo -fstype=cifs,rw,credentials=/home/me/.foo-creds ://NAS.IP/foo

mailpreview updates

mailpreview-cli is a little program I use multiple times a day to quickly see my unread email without moving from what I'm currently working on and without touching my mouse. I recently noticed it wasn't grabbing the body of a specific type of email. In the process of fixing that I also added proper unit tests for every format I currently parse through. Yay faster feedback loops!

ffmpeg

I've been a fan of OBS for awhile now. I was recently doing a quick screen recording of my browser window and the browser window wasn't full-screen so there were black bars around the edges of the recording. I didn't love that but it's time to touch the "ffmpeg exists and is awesome" sign again.

This superuser post has the answer which consists of two steps:

1. Get the crop parameters of the video from ffmpeg. ffmpeg will detect the black borders and report back the actual content coordinates. ffmpeg.exe -i '.\some-video.mkv' -vf cropdetect -f null -
2. Re-encode and crop using the crop parameters to trim the borders. ffmpeg.exe -i '.\some-video.mkv' -vf crop=624:704:332:10 -c:a copy output.mp4
3. Enjoy your pristine video.

Links I've enjoyed

• Docker without docker Really anything on the fly.io blog is gold.
• David Crawshaw: SQLite and Go(Talk)
• DNSFS
• Writing Small CLI Programs in Common Lisp
• My Dream of the Great Unbundling

Fin

-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -i eth1 -j ACCEPT
-A INPUT -i eth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i eth1 -o eth0 -j ACCEPT
-A FORWARD -i eth0 -o eth1 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

The benefit of running a x86 box with Alpine (or any version of Linux) is that the box will receive a steady stream of security updates and upgraded kernels as Alpine Linux releases new versions. This is a much better situation to be in than relying on OS and security updates from a vendor like TPLink or Linksys.

If you have ideas for how to improve the config I listed above or want to chat more about home network stuff, send an email to my public-inbox.

[..] install the siji font, and then run "view.sh" in the terminal. If you get an error, try to launch the install.sh again. You'll get a list of all the glyphs available, select the one you want [..] to use and then look where it says "Character 0x00e002" or something like that.

Of note is that you'll end up with weird looking glyphs but siji will interpret it correctly. This is because Siji maps character codes to different icons than other fonts do.

Turns out there's a Github issue that contains the solution which is to enable bitmap fonts which I'll paste here for posterity:

# "Un-disable" bitmap fonts
sudo rm /etc/fonts/conf.d/70-no-bitmaps.conf
# Clear the font cache
sudo fc-cache -f -v

Apparently Ubuntu disables bitmap fonts by default but polybar uses bitmap fonts for icon rendering. I also needed to install the sijj icon font family which was painless.

One thing to note is that the source code for all these projects is stored on sourcehut. Sourcehut (or sr.ht) bills itself as "the hacker's forge". I highly recommend checking it out. It's also where I host my public inbox.

hover-dns

Now that I have fiber internet at the house I've been hosting one-off services and apps on my own hardware at the house. This is great, however my residential connection is a typical dynamic IP not a static one. Instead of using a service like DynamicDNS I decided to write some Rust (shocker) and leverage the "unofficial" Hover API. The result is: hover-dns.

I have hover-dns running in a crontab for a few different domains to keep my domains pointed to the correct IP for my house. While I'm a little uncomfortable with how similar npm and cargo can feel, the trust-dns package is excellent. I was able to quickly read the source code to understand how to setup a Resolver for opendns. Also impressive is that hover-dns ip beats out dig in returning your public IP. I didn't expect that!

podcastfilter

Speaking of hosting things at home, podcastfilter.com is one of those things. podcast-filter is a small Go project that allows you to filter a podcast feed by each episode's description and return a feed of just those episodes that match.

mailpreview

The recent project I use the most day-to-day is mailpreview-cli. mailpreview-cli is very straight-forward, it accepts a Mail message and returns either the plain text version or the html version of that message. The reason I don't just pull the Mail message directly is because a Mail message can contain several versions of the message in different encodings (start here if you're curious: RFC-822). Instead of writing my own parser I grabbed the excellent mailparse crate and wrapped the behavior I wanted around it. On it's own mailpreview-cli isn't super fancy but I trigger it from rofi via a shell script which allows me to browse (and then view) all my unread emails right from rofi. Shameless plug: I wrote a short post about getting started with rofi if you're unfamiliar. mailpreview-cli could be used with Alfred if you're on a Mac to accomplish the same thing as I'm doing with a shell script and rofi.

Fin

I've been talking about Hacktoberfest with my co-worker Bryan and I thought of four different approaches to Hacktoberfest this year that I wanted to share.

Dependency scrub

This is probably common everywhere but the Javascript/web communities are filled with npm packages. It's packages all the way down. I think it would be interesting to approach this month looking for ways to remove third-party code from projects you love and use frequently.

Polygot Achievement

Try to submit four pull requests in four different languages. As Drew DeVault writes: Hack everything without fear!

Unknown lands

Similar to the previous one it could be fun to submit PRs against a project you've never been in before that's in a language you don't know. This could be anything from diving into Wordpress core, to working on some C for some Linux utilities, or even submitting PRs to open source Mac/iOS applications.

Bug doctor

Go into a project and find the oldest issues and try to resolve them via PR. This is inspired by Richard Schneeman's video and post where he runs through 11 issues and 2 PRs in a hour and a half.

How are you approaching Hacktoberfest this year? My public inbox is open, let me know!

• curl is open-source and has thousands of contributors but is still primarily designed and managed by @bagder (Daniel Stenberg). If you ever do anything with http for any kind of development mastering curl is worth the time investment.

• git is the premier version control system on the planet. It started out as a side-project to manage Linux kernel development.

• Alpine Linux is a Linux distribution that is maintained by a small group of folks and yet is the first choice for most folks when creating Docker images.

• sr.ht does not have the type of scale or impact that the others items on this list have but I think it could some day. sr.ht is version control host, issue tracker, mailing list tool, and CI toolbox. It competes directly with Github, Gitlab, and Bitbucket. However, sr.ht is run by one person—Drew DeVault—and is 100% open-source.