miccah.io

Ergonomic SSH development

Tue, 11 Aug 2026 09:00:00 +0000

I’ve been setting up a dev machine on my home server and doing all of my personal projects remotely over SSH. I’ve fiddled quite a bit with the system to make it ergonomic, so here are some of the things I’m quite happy with.

Tmux autocompletions

Of course, tmux is a t-must! One of the cool things about tmux is that you can programmatically read the contents of a pane via tmux capture-pane -S- -pt $PANE_ID, which means you can plug this data into autocomplete engines.

My NixOS dev machine

Sat, 01 Aug 2026 09:00:00 +0000

I have a home server that I built primarily for “cloud” gaming (read more about that here). I’m running Proxmox so I can install other services, one of which is my notes machine. After many years of experimentation, I’ve landed on a system that I like: I ssh notes@notes which drops me directly into nvim -c VimwikiMakeDiaryNote and disconnects on close. It’s a very lightweight version of an SSH app, which I’m starting to realize I like quite a bit.

Home cloud gaming server

Fri, 03 Jul 2026 09:00:00 +0000

At the end of 2024 I decided to build a new gaming PC. My existing one was a typical tower computer from 2012 that was big and loud and too old to run Elden Ring! So I decided it was time to make a new build, but this time, I wanted to do it a little different. I wasn’t thrilled with the idea of having a large and loud tower at my desk, so I thought it would be fun to build a server that could stream games to my laptop.

WireGuard is simply elegant

Mon, 30 Mar 2026 09:00:00 +0000

WireGuard is a secure, easy to use, and simple VPN solution that is the underlying technology for Tailscale. I’ve personally used it in both flavors and have been very happy with its reliability and the fact that it “just works.” So this week, I decided to learn how it can “just work” by reading the whitepaper describing its design and also watching the 2018 BlackHat keynote.

While I enjoy exploring the technical details of a secure communication protocol¹ and will dive into that later, I want to take some time to appreciate the simple elegance of the WireGuard protocol that I strive to match in my own work.

2025 Reflections and 2026 Goals

Tue, 06 Jan 2026 09:00:00 +0000

It seems like 2025 came and went in a flash. Looking back, I’m happy to say that I continued being social and made some more friends.

This past year, I..

Built a home server

Okay, I actually built it in 2024, but I used it a lot this year and had a lot of fun setting up VMs with Proxmox. I keep all of my notes there, a gaming VM, and various media containers too. It may be recency bias, but I installed immich and have had a great experience with it, and even started a photo frame project that has been a lot of fun.

An unexpected benefit to keeping notes

Sat, 17 May 2025 09:00:00 +0000

I keep a weekly journal of notable events, my feelings, and ideas. Most of the time, the value I get out of doing this comes from the act of writing it down in the moment. Writing notable events helps my memory, writing my feelings helps me understand and let them go, and writing my ideas helps me refine them.

This is largely unsurprising and overall very valuable to my mental health, but occasionally I look back over the years of notes and regain a perspective of myself that I so easily forget: I’m awesome. I’m not saying this to brag! Living day by day and falling into the rhythm of life really makes me forget all of the awesome shit I’ve done in the past. When I read about all of that in my own words, I often think, “how the hell did I do that?”

2023 Reflections and 2024 Goals

Fri, 01 Nov 2024 09:00:00 +0000

Okay, I know I’m finally finishing this post in NOVEMBER when 2024 is almost over, and it was mainly postponed because I lacked 2024 goals. So I’ve reflected on why and shared my thoughts below.

But first, 2023 reflections! I made a huge life change that made it a great year for me.

I moved to Seattle!

It took me awhile to get everything ready and find a place to rent, but I finally did it! I chose Seattle for a few reasons. The nature in the Pacific Northwest really calls to me, and I want to go on hikes and enjoy it. I also have a few friends in Seattle, so it was an easier transition socially. Finally, Seattle has a pretty good tech scene, so I’ll have more opportunities to make friends. So far, I really love it here and am grateful I made the jump!

Scripting a Zoho catch-all filter

Wed, 18 Oct 2023 09:00:00 +0000

I use Zoho as my email provider, and I recently learned that you can setup a catch-all forwarding address. This is pretty great, because that means I can receive any email sent to my domain! Go ahead, try it.

I want to sort the emails I receive into their own folder, though, depending on the delivery address (for example, lol@miccah.io will go to /catch-all/lol). It turns out, Zoho supports custom mail filters using a scripting DSL called deluge, so I wrote one!

Some git aliases

Wed, 26 Jul 2023 09:00:00 +0000

Have you ever wanted to know

I definitely stole these from somewhere.

[alias]
 checkout-pr = !sh -c 'git fetch origin pull/$1/head:pr/$1 && git checkout pr/$1' -
 oldest-ancestor = !zsh -c 'diff -u <(git rev-list --first-parent "${1:-main}") <(git rev-list --first-parent "${2:-HEAD}") | sed -ne \"s/^ //p\" | head -1' -
 branch-files = !sh -c 'git diff --name-only --no-merges --first-parent $(git oldest-ancestor origin/main)..HEAD | cat'

Not leetcode

Sat, 13 May 2023 09:00:00 +0000

Leetcode, for those who don’t know, is a collection of data structures and algorithms programming challenges. More often than not, I find it difficult to maintain interest in the problems because they all seem so contrived and it’s not that rewarding to solve.

There are plenty of articles about what’s wrong with leetcode, so instead, I’m going to share some alternatives that I have found much more engaging and actually useful. For what it’s worth, these challenges tend to be more involved than ones you would find on leetcode.

Practical git usage

Sun, 09 Apr 2023 09:00:00 +0000

I use git almost daily both personally and professionally, and my usage follows a pretty regular pattern. By sticking to this pattern, I rarely get into a sticky situation or unexpected state. As many can attest, git is a beast of a CLI tool, but these workflows have been enough to keep my projects organized.

Personal usage

Repositories where you’re the sole contributor are a lot easier to manage than a group project, so let’s start with that. Here’s my workflow:

What are Go interfaces?

Sat, 25 Feb 2023 09:00:00 +0000

I was talking to my coworker about interfaces when the question arose about why a concrete slice has to manually be converted into an interface slice. I’ll demonstrate this as a simple example.

ints := []int{1, 3, 3, 7}

var anys []any = ints // Error!
// cannot use ints (variable of type []int) as type []any in variable declaration

This is perhaps surprising because semantically every int is an any, so why doesn’t it work? I told my coworker it was because elements in a slice must all have the same size, and interfaces are wide pointers. It was a good enough explanation at the time, but it got me wondering.. are interfaces really wide pointers? How are they actually represented at runtime?

I am not interested in AI tools

Sat, 18 Feb 2023 09:00:00 +0000

There’s certainly good arguments for using AI tools like GitHub Copilot or ChatGPT, and there are certainly good arguments against them. This post isn’t about either. Instead, here’s my anecdote as to why I haven’t felt drawn to even try them out.

I was talking to a friend about DALL-E and how it is affecting the art community. The whole AI art gave me this odd dystopian feeling that I couldn’t quite articulate until this conversation. She told me that art isn’t about the end result. Artists make art because they love the process of making art.

2022 Reflections and 2023 Goals

Wed, 04 Jan 2023 09:00:00 +0000

2022 was a good year for me. I grew, gained more confidence, made new friends and reconnected with old ones.

Here’s a laundry list of what happened in 2022 and my thoughts on them.

Started keeping a diary

For some reason, I like recording things. At the beginning of the year I started using vimwiki and was able to tweak it to my liking. In the past I had used zim which I loved for its hierarchical structure and image embedding, but I eventually stopped using it. I’ve been able to stick with viwiki this year, and I quite like having each diary entry be for the week (Monday - Sunday). The best part is that I started adding summaries for each week and month on the index, so I can glance through my past highlights.

Never-graduated from Recurse

At the end of 2021 I decided to join the Recurse Center. I was in a 12 week batch (W1'21) that ended in February of 2022, and I absolutely loved my time there. I made many friends and joined a community that connects me with amazingly kind people that are as interested in programming as I am! I’m so grateful that I can’t ever graduate, and it has been a constant source of positive engagement and discourse throughout 2022.

Started working at a security company

Thanks to the Recurse Center career services, I interviewed a ton and was able to land an amazing job. I was specifically looking for a place with good culture that is fully remote, in the security industry, and mainly writing Go. Looking back at the 8 months I’ve spent at Truffle Security, I can confidently say that I found all of that and more. This is my first time working at a startup, and I’m certain my perspective of startups is now skewed with how good it has been.

Traveled!

I really wanted to travel more in 2022. Since I moved back in with my parents during the pandemic, I knew I needed to find a place I would like to live. Part of that process was traveling and getting comfortable traveling on my own.

Interests as Orbits

Sat, 19 Nov 2022 00:00:00 +0000

I watched a video recently about (mislabeled) laziness and how some people aren’t built for the “consistent and organized” lifestyle. I find this subject really interesting because I have noticed the effects of consistency and know how powerful they can be. But at the same time, I have also noticed my motivations and interests ebb and flow. It’s one of those situations where I know I should do something, but I’ll let it stew in the back of my mind until it bubbles to the front. I never thought this approach was inherently bad. It could be better, but it always worked itself out eventually.

Ones and Zeros

Sun, 23 Oct 2022 00:00:00 +0000

The root of digital logic is being able to differentiate between something and not something. This little seed has basically built the entirety of the information age. You’ve probably heard it before: a computer is just ones and zeros, but let’s explore this a bit (ha) in the context of programming and data.

Bits of Data

Data ultimately comprises of ones and zeros (called bits) stored in memory, and we can manipulate how it is represented using different types in a programming language. Let’s look at an example in C.

Rust's Display Trait

Wed, 12 Oct 2022 00:00:00 +0000

Rust’s trait system is pretty cool, and one of the common traits is Display. Defining an implementation for this trait will allow you to use the standard formatter {} with your type, but the official example is a bit misleading.

use std::fmt;

struct Point {
 x: i32,
 y: i32,
}

impl fmt::Display for Point {
 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 write!(f, "({}, {})", self.x, self.y)
 }
}

fn main() {
 let origin = Point { x: 0, y: 0 };
 println!("The origin is: {origin}");
}

The origin is: (0, 0)

Well, that output is expected, but what if we add some padding? This should right align, using - as padding, and a width of 10 (reference).

Go Contexts

Tue, 06 Sep 2022 00:00:00 +0000

Go is a simple language, but I was pretty confused by the context package when I first learned about it. I had trouble understanding how it could be used to set a deadline or to cancel functions or how it even worked. Since then, I’ve gotten a firmer grasp on how to use it both as a user and as a library author.

Let’s start by defining what a Context is and its purpose. A Context is a construct used to signal a function to stop its work and return. The key is that a function needs to be context aware in order for this to have any affect; there’s no magic.

The Joy of Keeping a Lab Notebook

Wed, 10 Aug 2022 00:00:00 +0000

In November of 2017, I began keeping a lab notebook for experiments (inspired by this document). My last entry was December of 2017 (a whopping two months of use) before I lost interest or motivation or both.

I rediscovered it a few days ago when I came across a project I had recorded in it. I had converted the 4-prong plug of a 1950’s era rotary telephone into a jack usable in today’s homes. I could vaguely remember the result, like the ringer not working and not being able to dial out. I decided to try it on a dedicated landline, and amazingly, it worked! I got a dial tone and could make calls! The ringer still didn’t work, but I kind of expected that.

My Technology Origin Story

Sat, 30 Jul 2022 00:00:00 +0000

How did I get interested in computers and programming?

Well, I grew up around computers. My parents were pretty technologically inclined, so we had computers and printers around the house. I particularly remember playing educational video games on a Compaq and later on, other games like Jump Start 2nd Grade, Pajama Sam, and Putt-Putt and Pep’s Balloon-O-Rama. My older brother also spear-headed the family in the console video game department. We had a SNES, then an N64, then a PS2 which accounted for a lot of my childhood.

Spring

Fri, 15 Apr 2022 09:00:00 +0000

When I read a book or watch a TV show, I’m excited to get to a new chapter. There’s more to discover, more to experience, and more to understand. So why are new chapters in life so scary to me when the exact same can be said? It’s hard for me to let go and move on, but I’m slowly progressing into a new chapter of my life. I’m excited and scared about it, but it feels right. I miss my previous chapter, but it’ll always be part of me. If I could go back though, I wouldn’t. That’s not my place anymore.

Interviewing is a full time job

Wed, 16 Mar 2022 09:00:00 +0000

This post is a recap of my recent experience job searching and a “thank you” for all the help I received along the way.

I’m sure you’ve heard it before, and if not, it’s a common sentiment to describe the amount of effort it takes to interview with multiple companies when job searching.

I recently underwent this process for the first time, and I 100% agree with the sentiment. Even though I have worked before, this is the first time I fully went “all in” on job searching. My process was three weeks straight of scheduling, interviewing, and following-up with 28 different companies.

How I Design Rust Programs

Wed, 23 Feb 2022 09:00:00 +0000

As I have learned and gained more experience using Rust, I noticed that the way I write Rust code is a bit different than the way I write in other languages.

When writing an application in Rust, I create the data structures I think I’ll need, then decide on “who owns what.” Which modules are responsible for which functionality. There’s a focus on organization, perhaps instigated by the borrow checker and the fact that one file is (usually) one module. This is enabled especially by the todo! macro which allows me to stub out function and method definitions without worrying about implementation details. Again, it’s a focus on how modules relate, how information is transformed, and the overall organization of an application.

MSP430 Programming and Debugging

Fri, 07 Jan 2022 00:00:00 +0000

(on linux)

The MSP430 launchpad is a low cost, low power microcontroller that can be used in a variety of embedded applications. This post documents how to program and flash the device on linux without TI’s IDE.

Note: the specific MSP430 device I’m using is msp430g2553.

Tools used

In addition to GNU Make, I installed these packages to cross compile, flash, and debug.

udev

This is optional, but if you want to program your microcontroller without sudo permissions, it would be a good idea to add a udev rule that will put the device in a group you are apart of. I chose wheel but you can use your own username or create a whole new group.

Rust traits are more powerful than I thought

Sat, 11 Dec 2021 00:00:00 +0000

I have been learning the Rust programming language in my spare time for a little over 2 years now. My first mental model of traits consisted of a contract for types that would implement the trait, similar to Go’s interfaces. It wasn’t until recently when I decided to explore traits during Advent of Code that I started to realize how integrated these contracts are into the language and standard library. Using traits really helped clean up the code I was writing.

HTTPS for your Home Server

Thu, 11 Nov 2021 00:00:00 +0000

Do you have a home server and would like to securely connect to it? Or are you tired of remembering your IP address? This post, as you may have guessed, describes software and technologies to easily setup HTTPS for your home server.

Warning: opening up your home server to the Internet is dangerous without proper precautions. Your server will be found by bots and they will attempt to gain access.

Serde and Nested Maps

Sat, 23 Oct 2021 00:00:00 +0000

In one of my Rust projects I am parsing very nested JSON structures. Let’s use the following example as our data source (though in reality it is 20+ deep):

{
 "foo": {
 "bar": [
 {
 "baz": {
 "x": "y"
 }
 }
 ]
 }
}

Serde is the de-facto framework for serializing and deserializing data efficiently in Rust. It supports parsing JSON into either strongly typed data structures or untyped JSON values.

Rust does not have a way to define anonymous structs, so for the strongly typed approach we would need to define 20+ separate structs to get the data we want. No, thank you.

Creativity in Software

Fri, 22 Oct 2021 00:00:00 +0000

I recently listened to an excellent talk by Jordan Peterson titled Exploring the Psychology of Creativity, and it got me thinking about how it applies to software development.

I came to the conclusion that software development is inherently creative. I think this is quite obvious when building a new project or writing new code, however even the maintenance of existing software has some room for creativity. Arguably less so, but there is room none the less.

What to Learn

Thu, 21 Oct 2021 00:00:00 +0000

I recently read a blog post by Dan Luu titled What to Learn. As a life-long learner, the simple title piqued my interest. I don’t tend to take recommendations about what other people find interesting, but I’m glad I decided to at least see what it said.

The advice Dan gives is not concrete or cheap, but the type of advice that incites self reflection and personal growth. He advises to focus on amplifying your strengths, as opposed to minimizing your weaknesses. Maybe this is obvious to most people, but I had not thought of learning in this way. It’s much more appealing to me to learn something completely new than to push the boundary in an area I am more than competent in, so hearing this made me think (more on this later).

Ground Up: State Machines

Sat, 18 Sep 2021 00:00:00 +0000

Welcome to a series of posts cleverly titled Ground Up, where I explain computing concepts from the ground up! We’ll explore how computers work starting with transistors and going from there. This post specifically covers finite state machines.

LangJam

Tue, 07 Sep 2021 00:00:00 +0000

Two weeks ago I participated in the first ever LangJam, the goal of which was to create a programming language based on a theme in a 48 hour period.

Now, I’m not exactly a seasoned programming language creator, but I am quite interested in the art. This jam was an excellent opportunity for me to grow my skills, interact with the community, and “complete” a minimal language just for fun.

The theme for this LangJam was “first class comments.” A challenging paradox for sure, however since I didn’t have the time to learn the intricacies of AST parsing and code generation, I decided to make something that’s very easy to understand and implement.

Ground Up: Memory

Sun, 18 Jul 2021 00:00:00 +0000

Ground Up: Gates

Tue, 06 Jul 2021 00:00:00 +0000

Ground Up: Bits

Fri, 18 Jun 2021 00:00:00 +0000

Welcome to a new series of posts cleverly titled Ground Up, where I explain computing concepts from the ground up! We’ll explore how computers work starting with transistors and going from there. This post specifically covers transistors, digital logic, and binary.

Part 1: Bits
[Part 2: Gates]({% post_url 2021-07-06-ground-up-gates %})
[Part 3: Memory]({% post_url 2021-07-18-ground-up-memory %})
[Part 4: State Machines]({% post_url 2021-09-18-ground-up-state-machines %})

Transistors

At the end of the day, computers are complex circuits built mostly of transistors. Transistors are electrical components that can be thought of as gates that allow or deny current to flow. That’s it. Try toggling the gate below to see how the current responds.

Gratitude

Tue, 08 Jun 2021 00:00:00 +0000

Gratitude is one of the simplest and most wildly rewarding practices I have ever adopted in my life. It’s so sneakily simple that you may think it’s nothing special, but regularly practicing gratitude changes how you think in the most positive way. It changes how you see life, how you feel, and how you experience the world.

Everything in life can be viewed in countless different ways, the classic example being the glass half full or half empty. I used to be a “half empty” person, but I have learned to be grateful for what is there, not what is lacking. What is not there does not exist and, the feeling of lack is a fabricated thought from my mind. It’s perfectly fine to want to feel that way, but I am happier seeing the positives.

Copying a new SSH key to a passwordless server

Tue, 01 Jun 2021 00:00:00 +0000

This is a scenario I have ran into a couple of times. I have a server that doesn’t allow logins with a password, and I need to setup a new computer or operating system so it can login.

It’s a simple problem, but I decided to record how I do it in case it helps others. This method requires you to already have pubkey access from another computer.

Copy the new public key to the computer that already has access

scp ~/.ssh/id_rsa.pub dipper:/tmp

# alternatively scp from dipper
scp mabel:~/.ssh/id_rsa.pub /tmp

From the computer that has access (dipper in this example), copy the ID to the server using ssh-copy-id

ssh-copy-id -fi /tmp/id_rsa.pub grunkel-stan

-f allows us to only use the public key and -i specifies the identity file. That’s it!

How doing nothing allowed me to grow

Mon, 24 May 2021 00:00:00 +0000

In January of this year, I left my corporate software engineering position to do nothing, and it was one of the best decisions I have made.

Before I get into the “why”, I’d like to point out that I am in a fortunate place to be able to leave my main source of income without lining up my next source. I was able to do this because I am young with few responsibilities, some savings, and on good terms with my parents, who happily welcomed me back home.

Effectiveness of Deadlines

Mon, 17 May 2021 00:00:00 +0000

Eight weeks ago I started tracking what I worked on each day. I laid out a star board for all of my interests, and I would fill in a square if I gave it attention that day. I call this “watering my ideas,” and it has hugely helped me remember and allocate time for the projects that I wasn’t giving enough attention to, including this blog.

Eight weeks ago I also gave myself a goal to publish a post every Tuesday. I have achieved that goal every week without fail, and I am so proud to be consistently adding to my website. The other interests on my board, however, have not seen similar progression.

Opinionated Design

Wed, 21 Apr 2021 00:00:00 +0000

When I first learned how to program, I was so excited about how I could create anything! The possibilities were endless and I could create in any way I choose. This is so powerful for creative coding, but I have learned that designing systems any way I want is not the best approach in a professional context.

For professional systems, opinionated designs flourish. The more specific problem your product solves, the better. This works for two reasons: it’s simpler and easier to understand as a customer and it’s simpler and easier to maintain as an engineer.

Thoughts on Abstractions

Wed, 21 Apr 2021 00:00:00 +0000

Computers are like onions. They stink, make you cry, and when you leave them out in the sun they get brown and start sprouting little white hairs.

Wait, that’s not right. Computers are like ogres! They have layers. Lots of layers. In fact, modern technology is built on abstractions. This is fantastic for containing complexity, assuming everything works as intended, because you can work on larger problems without thinking about the lower levels. For example, a developer can write a program that sends messages across the Internet without ever knowing how that data is physically sent.

Security Focused Development

Thu, 15 Apr 2021 00:00:00 +0000

As the security industry grows and more and more critical systems are put online, the demand for security focused developers will grow as well. Security focused development, as the name suggests, is software development with security in mind. Software engineers need to think like hackers while developing systems in order to keep users secure.

As an engineer with a strong interest in ethical hacking, I naturally think about how the code I write could be exploited. So here are my tips on secure software development.

Philosophy of Parkour

Wed, 14 Apr 2021 00:00:00 +0000

I first learned of parkour around 2012. I thought it was so cool, but I was too scared to even start. All the videos I saw were these crazy jumps at height or doing flips over concrete. It took me eight years to finally practice it myself, and I have learned so much from my experiences.

Parkour is such a unique and interesting sport because it is individualistic, creative, and physically demanding. At its core, parkour is about overcoming physical and mental obstacles. This is the philosophy of parkour that I have come to know. It is a progression of physically building the strength to overcome obstacles, then mentally overcoming your fears about movements you know you can physically do. It’s immensely personal, and it grows your relationship with yourself in a way I never thought a sport could. And because it is so individualistic, parkour is inherently creative. Every personal challenge is created directly by you.

Trusting Data

Thu, 08 Apr 2021 00:00:00 +0000

When creating programs, you will almost certainly operate on data. This could come from users submitting information to your website, or data read in from a database. Wherever it comes from, developers define how that data is used and what can be done with it. As such, it is important to think whether the data is trusted and safe to operate on, or if your program can be exploited when the data is changed.

Good Function Design

Tue, 06 Apr 2021 00:00:00 +0000

A fundamental part of software development is creating functions. It keeps your code organized, readable, and prevents duplication. Like any other skill, writing good functions can be improved with practice and intention. If you learn anything from this post, it should be that function call sites should be readable! A developer should be able to infer what a function does without knowing its definition.

Choosing when to create a function

I have learned many arguments and philosophies about this. There’s DRY (Don’t Repeat Yourself), which, as the name suggests, advocates for never repeating the same piece of code. There’s WET (Write Every Time), which aims to avoid abstractions and keep code simple. Finally, there’s the Rule of Three, in which you refactor when you are writing similar code for the third time.

The Importance of Types

Wed, 24 Mar 2021 00:00:00 +0000

There are many programming languages, but they can all be put into one of two groups. Those that are dynamically typed and those that are not. This post compares the two styles and will conclude with reasons why professional software development should use a statically typed language.

Let’s start with dynamic typed languages like Python and JavaScript. These languages are fantastic for learning programming and creating small projects. It is so easy to start writing code that just works, but the caveat is a lot of functionality is stored in the sole developer’s mind. So it’s easy if you’re the only developer of the project or if the codebase is small, but it will need more organization when it grows. This could mean more rigid development practices, external tooling, or bolting on (optional) types after the fact.

Little things make big things

Tue, 23 Mar 2021 00:00:00 +0000

All big things started small. It started as a thought, a seed, and with consistent watering grew into a big tree.

Doing little things consistently will grow into big things. It’s easy too! The hardest part is regularly showing up.

I like to imagine my ideas as trees. Each one is unique and they always start as a seed. By giving an idea attention, I’m watering it. If I don’t water it, it will never grow! Even worse, if I’m not consistently watering my tree, it will die.

If all you have is a hammer

Sun, 24 Jan 2021 00:00:00 +0000

..everything looks like a nail.

This is one of my favorite quotes because it is applicable to so many domains. As Wikipedia states, it depicts a cognitive bias towards using a familiar tool in any situation. Humans are very creative, and if all we know is hammer, we will definitely find a way to use it on a screw.

But the beauty in this quote is the reminder that there probably is a better tool for the problem you are trying to solve. Relying on only what you already know is counter-productive when the tools don’t fit the task, so it’s a good idea to do a quick search first. That being said, don’t adopt the latest technology du jour just because it is popular today. Assess the time / complexity trade-offs of learning a new tool versus using what you have.

getrandom Character Device

Mon, 11 Jan 2021 00:00:00 +0000

Today I read this article titled Myths about /dev/urandom. I stumbled upon it when trying to figure out why writing /dev/random to a hard disk was taking so long, and I learned a few interesting things. The most important being to always use /dev/urandom because it doesn’t block and it is just as secure.

I also learned about a syscall that behaves similar to /dev/urandom but will block when there isn’t enough initial entropy: getrandom. I took this opportunity to learn how to create my own character device that will output getrandom bytes indefinitely.

CTFs are about Learning

Sun, 20 Dec 2020 00:00:00 +0000

Capture the Flag (CTF) events are common competitions in the security field. Many CTFs use Jeopardy style challenges where you can pick and choose which ones you want to solve with varying point rewards. It is a ton of fun, but when I first started, I thought the goal of CTFs were to win. You get the most points, you win, and you get a prize! Of course that’s the point, right? Well, no, not really.

Vim REPL Driven Development

Sun, 13 Dec 2020 00:00:00 +0000

If you have ever programmed with REPL driven development, you will know that it is like programming without a blind-fold on. It makes development so much easier, faster, and have fewer errors.

So I decided to add a generic REPL to vim. This is so simple, yet so effective and flexible. The idea is to send highlighted text to the terminal window (included in vim already).

Since the terminal is running bash, you can execute python or irb or any other interactive session and send the commands there as well.

A Thought Experiment on Business Structure

Mon, 07 Dec 2020 00:00:00 +0000

This is a thought experiment about a hypothetical company. What if every employee at that company had the opportunity to choose the project they work on? Every December 1st, every employee could leave their current project and work on another project. Or start their own project. Or they could choose to continue their current project. What if repeats weren’t allowed? What kind of culture would emerge? What patterns might we see? Could a business really operate like that?

A Thought on REPL Driven Development

Sun, 22 Nov 2020 00:00:00 +0000

I recently watched a talk by Bret Victor titled “Inventing on Principle”, where he explains his principle for inventing and subsequently encourages the audience to find theirs. His principle is that creators should have an immediate connection with what they are creating. This is a major problem especially in software development where the author of a program will need to change a bit of code and rerun it to see the effects.

Finding my Principles

Fri, 13 Nov 2020 00:00:00 +0000

Last year I saw a talk by Bret Victor titled “Inventing on Principle”. If you have not seen it, I highly recommend it because it poses a question to the viewer: what are your principles? What would you fight for?

Since I saw that talk, I have been searching for my principles. It’s not something I have specifically thought about before, especially as a driving direction for my career. Bret states it may take some time to find your principles, but I am going to go ahead and reflect on my current state as a software engineer after three years of industry experience. What do I strive to achieve? What bothers me? How do the answers to these questions influence my inventions?

Behind Success

Sat, 07 Nov 2020 00:00:00 +0000

Behind every success is a mountain of failures. Each failure informs you in some way. You learn what went well and what did not go well, so you can try a different approach the next time.

Failure has been taught to me, and I suspect majority of others, as a very negative outcome. Having this negativity tied to the result of something causes a fear of that negative outcome actually happening. I can attest that fear of failure has definitely stopped me from attempting things, but I believe that changing how we see failure will liberate us to explore, learn, and find new opportunities without fear.

Build your own Birdfeeder

Sun, 25 Oct 2020 00:00:00 +0000

I have been thinking a lot about a verse from PoC||GTFO titled “A Parable on the Importance of Tools; or, Build your own fucking birdfeeder.” It is a short story about a man named Noah who decided to build a boat. His friends were confused and asked him why? Why not buy one, or rent one out for the weekend? Noah grew tired of their questions and stated “I’m building my own fucking birdfeed because they’ve got wood at the store.”

PIC from NULL: Programming Concepts and Tips

Thu, 22 Oct 2020 00:00:00 +0000

This tutorial aims to get beginners started with PIC programming. This is the second post of the cleverly named series PIC from NULL. To understand PIC flashing, please refer to the first post: [PIC from NULL: Flashing]({% post_url 2020-09-12-pic-from-null-flashing %}).

This post covers some basic C programming concepts and tips in the context of MPLabX. If you are unaware, MPLabX is the official IDE (integrated development environment) for programming and debugging PIC microcontrollers.

PIC from NULL: Flashing

Sat, 12 Sep 2020 00:00:00 +0000

As part of my reintroduction to electrical engineering, I thought it would be fun to PICk up a new type of microcontroller: PICs!

These series of posts will document the challenges I faced when starting out and hopefully helps others in similar situations. This specific post covers flashing an 8-pin PIC16 using a PICkit3.

Preface

Before we get into the details of my struggle, there is some context you should know about. I am using an 8-pin PIC16 in a dual in-line package (the kind of package that fits in a bread board). I’m also using a PICkit3 which is no longer available from Microchip, but I got one on Amazon for a good price. It came with a ZIF socket, which I had zero knowledge about as well.

IoT Hacking: Starting Out

Mon, 10 Aug 2020 00:00:00 +0000

This past weekend I (virtually) attended DEFCON 28. It was my first DEFCON experience, and I have to say it was really great! There were so many talks that interested me with very friendly speakers and community. The IoT Village in specific really spoke to me, and inspired me to start learning hardware hacking more in depth.

I think this has been a long time coming. Working as a software engineer is great, but I have always missed working on hardware. Some of my proudest projects are on microcontrollers, so pursuing this definitely made sense for me.

Integrating clap and rustyline

Wed, 05 Aug 2020 00:00:00 +0000

My latest project is a command line interpreter written in Rust. As such, I wanted to use rustyline for the line reader and clap to parse that line. This post explores how I integrated these two libraries to leverage a single source of data for both command parsing and tab completions.

TLDR; here is a POC gist

Why I chose to do this

One behavior of Rust is informing the compiler of data that is related, so I thought it made sense to have my tab completion be based off of clap’s argument parsing. In this way, whenever I add, remove, or modify the argument parsing code, the tab completion will stay in sync.

Why I Prefer Rust Error Handling Over Go

Sun, 14 Jun 2020 00:00:00 +0000

A large part of software development is handling errors. Generally speaking, we cannot predict and account for everything that is input to the program, but it is important to handle issues gracefully as the algorithm encounters them. Like it or not, as engineers it is our job to provide a good user experience and that includes error handling.

This post describes my experiences with error handling in two programming languages: Go and Rust. We compare a simple example of reading the contents of a file.

QWERTY to Dvorak: A Short Story

Sat, 29 Feb 2020 12:00:00 +0000

It wasn’t easy, and it wasn’t hard. It happened before I knew it was happening. I was just trying to learn Dvorak for fun, but I went too far into the woods and I lost direction. All of a sudden I was in a limbo. I wasn’t proficient in Dvorak, and I wasn’t proficient in QWERTY anymore. Typing became a challenge and it forced me to really think before writing text down. In this limbo, I was faced with a question: do I keep walking through the woods, hoping for greener pastures on the other side? Or do I turn around and try to find my way back?

QWERTY to Dvorak: My Experience

Sat, 29 Feb 2020 12:00:00 +0000

I recently transitioned to the Dvorak keyboard layout from the traditional QWERTY style. This post will compare the advantages and disadvantages of each, and my experience of transitioning from QWERTY to Dvorak.

QWERTY

The most advantageous feature of QWERTY is its widespread adoption. It is used everywhere and is the default on 100% of the keyboards I have encountered. There is a real convenience with going anywhere and being able to fluently type without fiddling with settings. This comes most into play in public places like stores where you are asked to input your email or other personal information. Since I switched to Dvorak, those interactions have been painfully slow. Additionally, any time a loved one wants to use my computer (or I theirs), there would now be an extra step of changing the keyboard layout. In reality, however, I’m never actually using someone else’s computer, so in those very rare cases I usually just “hunt and peck.”

How Zim Helped Organize My Life

Sun, 26 Jan 2020 12:00:00 +0000

I am a lifelong learner, and I love to take notes. Any type of notes. There is something about recording knowledge that just gets me excited! Note taking is a common practice among high school students, using pen and paper. When I went to college, I began taking digital notes. Being somewhat of a perfectionist, I would write them using LaTeX. It would take twice as long, but I was convinced the end result was always better. As I transitioned into adulthood where formal classes are rare, I pretty much stopped taking notes altogether. Job related tasks did not warrant a cause for notes. It was a different type of learning at work. I would use sticky pads here and there, but I was not convinced I should be taking notes daily. In addition, my strive for perfection dissuaded me from even beginning. Daily tasks and job responsibilities are messy, often ill defined. How could I even begin to capture that in a file?

Git Started: Advanced Tips

Sat, 19 Oct 2019 00:00:00 +0000

This tutorial aims to explain Git in a way beginners can understand. This is the third post of the cleverly named series Git Started. In this post, I will share some useful tips for using git on the command line. For a conceptual understanding of Git, please refer to the first post: [Git Started: Introduction]({% post_url 2019-09-21-git-started-introduction %}). For an introduction on git CLI usage, please refer to the second post: [Git Started: Basic Usage]({% post_url 2019-10-10-git-started-basic-usage %}).

Git Started: Basic Usage

Thu, 10 Oct 2019 00:00:00 +0000

This tutorial aims to explain Git in a way beginners can understand. This is the second post of the cleverly named series Git Started. In this post, we explore how to use git on the command line. To get a conceptual understanding of Git, please refer to the first post: [Git Started: Introduction]({% post_url 2019-09-21-git-started-introduction %}).

Let’s begin by exploring the general project workflow, so we can understand what we need to use Git for.

Git Started: Introduction

Sat, 21 Sep 2019 00:00:00 +0000

This tutorial aims to explain Git in a way beginners can understand. These series of posts, cleverly named Git Started, will begin with the major concepts, and we will explore how to use git later on.

What Even is Git?

Many people will answer this by saying “Git is a version control system for tracking changes in computer files.” If you understand this, great! I believe an easier way to think of Git is as a way to save your files at different points in time. Like saving your video game state in new save locations, so you can go back later and replay the different paths. Git does exactly that, just with cheat codes to modify the saved states.

Optimize Your Terminal Workflow

Tue, 17 Sep 2019 13:12:15 +0000

Working in a terminal emulator is great for getting things done fast, and there are so many useful plugins and tools to make that experience faster and easier. In this post I will share the most useful tools and configurations that have improved my workflow significantly. All of these configurations can be found on GitHub.

Before I get started, however, note that I am a vim user, so most of the following will be vim-related. Actually, while we are on the subject, let’s start the list off with vim!

Welcome to miccah.io!

Thu, 12 Sep 2019 00:06:04 +0000

I am excited you are here, and I hope you learn something new in my posts.

Please feel free to contact me with any questions.

/about

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

Hi, I’m Miccah!

I like thinking about stuff and goofin’ around with computers. Self hosting, local-first, privacy, simplicity, and performance generally pique my interest.

Check out my /now page for my current interests!

Please feel free to contact me via email for any reason (or no reason!) at all.

/now

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

My interests (in no particular order):

SSH apps
NixOS
eBPF / XDP
immich-photo-frame
UX / design
Writing
Parkour

Last updated: August 1, 2026

Arduino

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

Arduino is a hardware and software company that produces single-board microcontrollers. Their products are open source and geared toward hobbyists. They also provide an IDE to program the boards using C or C++.

Hello World

hello_world/hello_world.ino

void setup() {
 Serial.begin(9600);
 while (!Serial);
 Serial.println("Hello, World!");
}

void loop() {}

# load the program onto the board
arduino --port /dev/ttyUSB0 --upload hello_world/hello_world.ino

# connect to the serial interface
screen /dev/ttyUSB0 9600

Bash

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

The Bourne Again Shell, bash, is a standard command line interpreter that is POSIX compliant.

Hello World

echo "Hello, World!"

Redirection and Substitution

Symbol	Description	Example
`	`	Pipe STDOUT from one command to STDIN of another
`>`	Redirect STDOUT	`ls > output.txt`
`>>`	Redirect STDOUT and append to file	`ls / >> output.txt`
`2>`	Redirect STDERR	`ls 2> output-err.txt`
`2>>`	Redirect STDERR and append to file	`ls / 2>> output-err.txt`
`<`	Redirect file as STDIN	`echo 'hello world' > a; grep 'hello' < a`
`<<EOF`	Read in text until `EOF` is encountered and send as STDIN	`grep 'hello' <<EOF\nhello world\nEOF`
`<<-EOF`	Same as `<<EOF` with leading tabs removed	`grep 'hello' <<EOF\n\thello world\nEOF`
`<<<`	Redirect string as STDIN	`grep 'hello' <<< 'hello world'`
`>()`	Receive STDIN to command as a file	`echo 'hello world' > >(grep 'hello')`
`<()`	Send STDOUT of command as a file	`grep 'hello' <(echo 'hello world')`
`$()`	Use output of command as string	`echo '/tmp' > a; ls $(cat a)`
`$(())`	Use output of arithmetic as string	`echo "1+1 is $((1+1))"`

Control Operators

Symbol	Description
`[` `test`	Condition evaluation utility command
`if` `elif` `else`	Evaluate statement if the return code is 0
`[[ ]]`	Shell built-in to enhance `[`
`for`	Iterate over a list of values
`while`	Do commands while command returns 0
`case`	Selectively execute commands based on matching pattern
`select`	Continuously ask for user to select a choice from a list and execute commands

Single vs Double Bracket

[ or test is a command whereas [[ is a shell built-in. I prefer [[ over [ because it offers better regex and boolean operations.

C

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

The C programming language is commonly used in embedded and operating systems. I see it as a “low level” language that is one step above assembly. It is very easy to work with raw resources, and a firm understanding of how a computer works will benefit the C programmer. Due to its lack of strict checking and manual memory management, it is also very easy to make mistakes.

Hello World

#include <stdio.h>

int main(int argc, char **argv) {
 printf("Hello, World!\n");
}

Pointers

A pointer is an address of a memory location. The type of the pointer defines how large that memory location is, so a int* is (in most cases) 4 bytes. The following example demonstrates this, as well as endianness.

Clojure

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

Clojure is a functional dialect of lisp. It is built on top of Java which makes interoperability easy. One thing I like about Clojure: the more concise the code is, the more readable it is. Additionally, functional programming (with a REPL) is quite productive and rewarding.

Because Clojure is a dialect of lisp, it follows the paradigm of “code as data”.

Hello World

(println "Hello, World!")

Functions

(defn function-name
 "function description"
 [args]
 (body)
)

You can also execute different code given the argument arity. This is useful for setting default argument values.

Complex Numbers

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

Complex numbers are numbers that consist of a real and imaginary part. Usually it is of the form $a + jb$ where $a$ and $b$ are real values and $j$ represents $\sqrt{-1}$. Complex numbers can be visualized as a plane where the real part is the x-axis and the imaginary part is the y-axis.

Polar Form

Complex numbers can be thought of as Cartesian points on a plane, and subsequently, they can be expressed as polar coordinates.

DNS

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

The Domain Name System is a decentralized naming system for computers connected on a network. It primarily translates human readable domain names into IP addresses. The job of assigning domain names and mapping them to Internet resources goes to authoritative name servers for each domain. A DNS name server is a server that stores DNS records for a domain. It responds with answers to queries against its database.

Resource Records

Here are the most common resources stored in a DNS name server.

Docker

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

Docker is a set of products that use OS-level virtualisation to deliver software packages called containers. The primary advantage of containerization is it allows for applications and their dependencies to be fully contained in a single, reproducible environment.

Reference: Containers

Components

Docker consists of three main components: the Docker daemon, objects (images, container, and services), and registries. The daemon is responsible for managing containers and listening for requests sent via the Docker Engine API. The docker CLI is also used to interact with the daemon.

Dvorak Keyboard

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

The Dvorak keyboard layout is designed to be a faster, more ergonomic alternative to the QWERTY layout.

Personally, I have switched my phone layout to use Dvorak while keeping my computer’s layout to QWERTY. Typing on my phone is now a lot easier and faster, and it has definitely been a great way to learn the Dvorak layout. Surprisingly, this has not affected my normal keyboard usage at all.

Electrical Components

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

These components are a few of the many building blocks of analog circuits.

Component	Description	Schematic Symbol
Resistor	Limits current
Capacitor	Stores electric charge
Inductor	Stores energy in a magnetic field
Diode	Allows current flow in one direction
Transistor	Amplifies or switches electric signals

Relationships

All of these components have mathematical relationships with voltage and current. The most useful one being Ohm’s Law.

ELF

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

The Executable and Linkable Format is a standard file format for executable files, object code, shared libraries, and core dumps.

ELF is flexible by design, extensible, and cross-platform. On the left is a typical layout of an ELF file. Once it is loaded into memory, the program will look like the layout on the right.

Program Sections

Name	Description
text	Read-only program instructions and data
data	Statically initialized non-zero data
bss	Uninitialized or zero data
heap	Runtime allocated memory
stack	Runtime memory used for local variables and function calls

Elixir

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

Elixir is a functional, dynamically typed programming language that runs on the BEAM (Erlang).

Hello World

IO.puts("Hello, World!")

elixir hello.exs

Enumeration

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

Once you have a foothold, the next step is to enumerate. This is an important step, because to exploit a system, you have to know what is on it!

Linux

Windows

JAWS
WinEnum

Finite State Machine

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

A finite state machine is a mathematical model of computation to define the solution to a problem. It describes the system as a machine that changes state in reaction to inputs to produce the appropriate outputs. State machines are usually defined with drawn diagrams or a table. Examples of each follow.

State Machine Model

State Transition Table

Input \ Current State	State A	State B	State C
Input X	State A	State B	State B
Input Y	State B	State C	State A
Input Z	State B	State B	State C

Moore Machine

A Moore machine is a finite state machine whose output is determined solely by its current state. In the representation of a Moore machine, the output is written on the state. Generally, Moore machines require more states than Mealy machines.

Format Strings

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

The printf family of functions accept a format string as an argument which may be used for formatting the list of arguments passed to the function.

int printf(const char *restrict format, ...);

It is unsafe to use user-supplied input as the format string because there is a directive (more below) that can write an integer to a memory location. Further, the format string can expose any data that is on the stack.

Reference: man 3 printf

GDB

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

The GNU Debugger is a tool used for debugging another program while it executes. You may set breakpoints, examine memory and registers, and step through the code line by line or instruction by instruction.

This tool is most useful for reverse engineering an unknown executable or debugging a C program you are writing. GDB Enhancement Features is a popular addon specifically for reverse engineering and exploitation.

Commands

There are many commands, but here are some common ones. Note that most commands may be abbreviated.

Git

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

Git is a revision control system that is very popular in software development. Sites like GitHub and GitLab offer hosting services for your projects. I enjoy using Git for my projects because I see it as saving snapshots in time, and I will always be able to go back to that version, no matter how much I experiment. I have written a [couple of blog posts]({% post_url 2019-09-21-git-started-introduction %}) on the subject as well.

GoLang

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

GoLang is a relatively new programming language. I consider it a “middle level” language because it is strictly-typed, compiled, and provides more protections than C. It also has a garbage collector, lightweight concurrency models, and builtin chan and error types.

Hello World

import "fmt"

func main() {
 fmt.Println("Hello, World!")
}

Concurrency

GoLang offers a concurrency model using goroutines, which are lightweight threads managed by the Go runtime.

go func() {
 // do something
}()

Channels

Channels are a “typed conduit through which you can send and receive values with the channel operator, <-.” It is basically a buffer to send and receive data. Sending will block when the buffer is full, and receiving will block when the buffer is empty. By default, a channel is unbuffered, but you can change the size on initialization.

Graphviz

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

Graphviz is an open source graph visualization software. It reads a text file description of a graph and generates an image automatically.

Reference: Graphviz - Graph Visualization Software

Usage

Graphviz provides many binaries for building the image:

binary	description
`dot`	filter for drawing directed graphs
`neato`	filter for drawing undirected graphs
`twopi`	filter for radial layouts of graphs
`circo`	filter for circular layout of graphs
`fdp`	filter for drawing undirected graphs
`sfdp`	filter for drawing large undirected graphs
`patchwork`	filter for squarified tree maps
`osage`	filter for array-based layouts

I mostly use dot.

HTTP

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

Hypertext Transfer Protocol is an application protocol for distributed information systems. HTTP is the foundation of data communication for the Internet. It is a request-response protocol in which the client sends a request to the server. The server then either provides a resource or performs a function on behalf of the client and sends a response message back to the client. The response contains a status code and possibly a body containing the requested resource or other information.

Java

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

Java is the first “real” language I learned. I consider it a “middle level” language for its static typing, garbage collection, rich libraries, and object oriented focus.

Hello World

public class HelloWorld {
 public static void main(String []args) {
 System.out.println("Hello, World!");
 }
}

Objected Oriented

Java is an object oriented programming language. Besides simple types like int, double, and char, everything is an Object. Objects must start with a capital letter (such as String).

JSON

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

JavaScript Object Notation is a standard file format that uses human readable text to transmit structured data objects. It originated from JavaScript, however, it is a language independent format.

{
 "hello": {
 "list": [1, 2, 3]
 },
 "greetings": [
 {
 "language": "English",
 "greeting": "hello"
 },
 {
 "language": "Spanish",
 "greeting": "hola"
 }
 ]
}

JSON uses the following data types: number, string, boolean, array, object, and null.

JWK and JWKS

JSON Web Key is a JSON data structure that represents a cryptographic key.

Kasa Smart Devices

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

Kasa is a brand of “Smart” devices (aka a WiFi connected and controlled) that is useful for adding logic to some appliances around your home.

Smart Plug

I have a smart plug that can be controlled via tplink-smarthome-api. It’s a npm application, which isn’t great, but it’s one that I found that allows you to send raw JSON requests.

# Install
npm install -g tplink-smarthome-api

API Reference

I searched far and wide and found this excellent research as well as this API reference someone put together. Unfortunately the API had to be reverse engineered since Kasa doesn’t make it public.

Kirchhoff's Laws

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

Kirchhoff’s Current Law

For any node in an electrical circuit, the sum of currents flowing into that node is equal to the sum of currents flowing out of the node.

$$ \sum_{k=1}^{n} I_k = 0 $$

Kirchhoff’s Voltage Law

The directed sum of the potential differences (voltages) around any closed loop is zero.

$$ \sum_{k=1}^{n} V_k = 0 $$

Kubernetes

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

Kubernetes is an open source container orchestration platform for automating application deployment, scaling, and management. It is commonly used to deploy microservices because it provides mediations for some of the concerns associated with microservice models.

Reference: Kubernetes Wikipedia

Cluster

A cluster is a collection of nodes, or workers where containers are deployed. Every node must run containerization software (e.g. Docker), Kubelet, and Kube-Proxy. Kubelet is responsible for the running state of each node, ensuring all containers on the node are healthy. If the state of a pod is not healthy, the Kubelet redeploys to the same node. It also relays node status to a primary (via a heartbeat) which can handle node failures. Kube-Proxy is the network proxy and load balancer of Kubernetes. It is responsible for routing traffic to the appropriate container based on IP and port number of the incoming request.

Learning

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

I am a life long learner. I love to learn new things specifically about building and designing things. I think this roots from my childhood: playing with Legos and building high tech houses in Garry’s Mod allowed my creativity to grow.

Style

I learn best by doing. Having the experience, doing the lab, and playing with the subject solidifies the knowledge for me. Prior to gaining experience, watching experts or lectures and taking handwritten notes is the best way for me to learn concepts.

Linear Congruential Generator

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

Linear Congruential Generator is an algorithm to produce a sequence of pseudorandom numbers.

$$ X_{n+1} = (aX_n + c) \bmod{m} $$

Reference: Linear Congruential Generator

Non-repeating PRNG

When $c \neq 0$, correctly chosen parameters allow a period equal to $m$, for all seed values. This will occur if and only if:

$m$ and $c$ are relatively prime (coprime)
$a-1$ is divisible by all prime factors of $m$
$a-1$ is divisible by $4$ if $m$ is divisible by $4$

These three requirements are referred to as the Hull-Dobell Theorem.

Linux

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

Linux is a family of open source operating systems stemming from Unix. Common Linux distributions include: Debian, Ubuntu, and Fedora. Personally, my Linux distribution of choice is Arch Linux.

Command Line Interface

All Linux distributions have a command line interface (CLI) usually running bash. It is a way to quickly and efficiently perform tasks on the computer using available commands. The CLI is particularly suited for automation of repetitive or delayed tasks, and provides very simple inter-process communication.

Logic Gates

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

The building blocks for integrated circuits and electronics. A logic gate is the electrical implementation of boolean expressions.

Gate

I/O

Symbol

NOT

A	Output
0	1
1	0

AND

A	B	Output
0	0	0
0	1	0
1	0	0
1	1	1

NAND

A	B	Output
0	0	1
0	1	1
1	0	1
1	1	0

A	B	Output
0	0	0
0	1	1
1	0	1
1	1	1

NOR

A	B	Output
0	0	1
0	1	0
1	0	0
1	1	0

XOR

A	B	Output
0	0	0
0	1	1
1	0	1
1	1	0

XNOR

A	B	Output
0	0	1
0	1	0
1	0	0
1	1	1

IMPLY

A	B	Output
0	0	1
0	1	1
1	0	0
1	1	1

Combining these basic building blocks we can achieve complex functionality.

Circuit	Description	Diagram
SR Latch	Set / reset latch is a simple circuit to preserve state.

MAC

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

Message authentication code (MAC) is a piece of data that is used to confirm that the message came from the stated sender and has not been changed.

HMAC

HMAC is a specific type of MAC that uses a cryptographic hashing algorithm along with a secret key.

Encrypt-then-MAC

Encrypt-then-MAC refers to encrypting the message first, then generating the MAC using the cipher text. It is preferred over MAC-then-Encrypt because it:

Provides integrity of the cipher text and plain text
No information can be leaked from the MAC, assuming the cipher text appears random
MAC-then-Encrypt must decrypt before authenticating the message
- Allows an opportunity for vulnerabilities in the decryption implementation

Make

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

Make is a utility to maintain groups of programs. Its purpose is to automatically determine which pieces of a large program need to be recompiled and issue the commands to recompile them. Generally, it can describe any task where some files must be updated automatically from others whenever the others change.

Make requires a Makefile to tell it what to do. The rest of this entry will contain details on Makefile syntax, best practices, and other useful information.

Modular Arithmetic

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

Modular arithmetic is a type of mathematical arithmetic in which numbers (consisting entirely of integers) wrap around a modulus. An intuitive example is time past 12:00 wraps around to 1:00, however in math the possible values are $ \left[0, modulus-1 \right]$.

A value in modular arithmetic is also the remainder when dividing by the modulus. This is common in computer science and programming languages as the % operator. For example, $12 \bmod{10} \equiv 2$.

MSP430

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

The MSP430 is a 16-bit MCU from Texas Instruments. It was designed for low cost and low power environments.

User Guide

Instruction Set

Notebooks

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

For some reason, I really enjoy owning notebooks and writing in them. My favorite I have found is the Leuchtterm 1917 Notebook. It has numbered and dotted pages, a pocket in the back, stickers for archiving, and a clean style. I wish I had found it in high school or college!

Pickle

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

Python includes a serialization library called pickle to write / read Python objects. It uses a stack based language for the interpreter.

Instruction	Description
`c`	Read to the newline as the module name; read the next line as the module object; push `module.object` onto the stack
`(`	Push a MARK object onto the stack
`S`	Push trailing string in quotes onto the stack
`V`	Push trailing unicode string in quotes onto the stack
`l`	Pop everything off the stack until MARK into a list; push the list back onto the stack
`t`	Pop everything off the stack until MARK into a tuple; push the tuple back onto the stack
`R`	Pop two objects off the stack (argument and callable); apply the function to the arguments; push the result back onto the stack
`p`	Read to the newline as the `index`; peek at the top stack object and store it in memo `index`
`g`	Read to the newline as the `index`; grab an object from memo `index` and push onto the stack
`0`	Pop and discard the topmost stack item
`.`	End of the pickle

Arbitrary Code Execution

The following will spawn /bin/sh when unpickled and is equivalent to:

PowerShell

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

PowerShell is a command line interpreter originally built for Windows but is available for all systems. Its best advantage over bash is its focus on structured data manipulation. It follows a Verb-Noun syntax which can make remembering commands easier as well.

Hello World

Write-Output "Hello, World!"

Help

# get examples for Command-Name
Get-Help -Name Command-Name -Examples

# discover powershell cmdlets
Get-Command

Aliases

PowerShell has many aliases that map to familiar bash commands. It is definitely helpful to use aliases because the command syntax tends to be a lot to type, however I think it’s important to know the underlying command format and not rely on aliases to get by.

Python

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

Python is a general purpose programming language that is very easy to use. I consider it a “high level” language because it has object oriented structures, garbage collection, dynamic typing, and it is interpreted. Python aims for readable code by using indentation for code blocks as well.

Hello World

print('Hello, World!')

Types

Python has the expected basic types of any programming language: boolean, int, float, string, arrays, and hashes. In addition to those, there are also complex numbers, tuples, and sets.

Python Pandas

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

Import Data

import pandas as pd

# with headers
df = pd.read_csv('filename.csv')

# without headers
df = pd.read_csv('filename.csv', names='column names'.split())

# specific columns
df = pd.read_csv('filename.csv', usecols='column names'.split())

Convert to Datetime

# automatic conversion
df['column'] = pd.to_datetime(df['column'])

# with format (usually faster)
df['column'] = pd.to_datetime(df['column'], format='%d/%m/%Y')

Reference: strftime

Reconnaissance

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

Passive Reconnaissance

Passive reconnaissance is the act of gathering information about your target without directly interacting with the target. There is a lot of information that you can obtain, including employee names and emails, servers, hostnames, even employee images or badge photos.

Passive Recon Tools

There are many tools out there, but here are some to get started.

Google Fu – Find hosts, files, or any publicly indexed information

site:example.com -site:www.example.com
site:example.com filetype:pdf
site:example.com inurl:etc -intext:etc ext:passwd

Certificate Transparency – Find issued certificates

REST

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

Representational state transfer (REST) is a software style for creating web services. A RESTful web service allows the requesting system to access and manipulate textual representations of resources by using a uniform and predefined set of stateless operations.

Resources

There are two types of resources: collection and member. A member resource is a single resource that the system will manipulate. A collection resource is a collection of members in which a single operation can be applied to all members of the collection.

Ruby

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

Ruby is a programming language that is similar to Python but with notable differences. I consider it a “high level” language because it uses dynamic types, garbage collection, and everything is an object. Its syntax is designed to make the programmer happy and is generally minimalist.

Hello World

puts 'Hello, World!'

Symbols

One interesting features of Ruby is the idea of a symbol. A symbol is a program wide unique identifier for anything. There is no need to create them or assign them. To reference a method, you can use its symbol. A symbol looks like a variable prefixed with a colon: :symbol.

Rust

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

Rust is a systems programming language designed for memory safety and performance. It takes a novel approach to memory management through an ownership system. The rust compiler keeps track of which variables own data (memory on the heap), and will free the data when the variable goes out of scope. It also keeps track of where the data is borrowed (where it is referenced) with distinction between mutable and immutable references. Overall, it can be a bit difficult to write rust programs at the beginning, but it gets easier with practice and makes you think differently about your program.

Songs that Build

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

Title	Artist	Link
Auto Rock	Mogwai	YouTube
Intro	The XX	YouTube
I Will Possess Your Heart	Death Cab for Cutie	YouTube
The Pretender	Foo Fighters	YouTube
But, Honestly	Foo Fighters	YouTube
The Ecstasy of Gold	Ennio Morricone	YouTube
Dream On	Aerosmith	YouTube
Lux Aeterna	Kronos Quartet	YouTube

SQL Injection

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

SQL injection is a type of attack that injects malicious SQL statements into input forms in an attempt to bypass authorization or retrieve sensitive information directly from the SQL database.

Essentially, user-supplied SQL statements are being executed on the database. This happens usually by improper sanitation of inputs, or improperly creating the query.

Example

statement = "SELECT * FROM users WHERE name = '" + userName + "';"

Using the input ' OR '1'='1 we get the statement

SSL/TLS

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

SSL (secure sockets layer) and TLS (transport layer security) are two protocols that attempt to provide confidentiality, integrity, and authentication when communicating across networks. Technically, the SSL protocols are deprecated in favor of TLS, however these two terms are often used interchangeably because TLS built off of SSL.

Confidentiality, integrity, and authentication are common properties in information security.

Confidentiality - only authorized individuals have access to information
Integrity - the information has not been modified
Authentication - individuals are who they say they are

Confidentiality is provided by encryption (either asymmetric or symmetric) and integrity and authentication is provided by hashing and MACs. Authentication cannot be fully provided without a Certificate Authority, however.

strtime

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

GNU Date

Directive	Meaning
`%%`	a literal %
`%a`	locale’s abbreviated weekday name (e.g., Sun)
`%A`	locale’s full weekday name (e.g., Sunday)
`%b`	locale’s abbreviated month name (e.g., Jan)
`%B`	locale’s full month name (e.g., January)
`%c`	locale’s date and time (e.g., Thu Mar 3 23:05:25 2005)
`%C`	century; like %Y, except omit last two digits (e.g., 20)
`%d`	day of month (e.g., 01)
`%D`	date; same as %m/%d/%y
`%e`	day of month, space padded; same as %_d
`%F`	full date; like %+4Y-%m-%d
`%g`	last two digits of year of ISO week number (see %G)
`%G`	year of ISO week number (see %V); normally useful only with %V
`%h`	same as %b
`%H`	hour (00..23)
`%I`	hour (01..12)
`%j`	day of year (001..366)
`%k`	hour, space padded ( 0..23); same as %_H
`%l`	hour, space padded ( 1..12); same as %_I
`%m`	month (01..12)
`%M`	minute (00..59)
`%n`	a newline
`%N`	nanoseconds (000000000..999999999)
`%p`	locale’s equivalent of either AM or PM; blank if not known
`%P`	like %p, but lower case
`%q`	quarter of year (1..4)
`%r`	locale’s 12-hour clock time (e.g., 11:11:04 PM)
`%R`	24-hour hour and minute; same as %H:%M
`%s`	seconds since 1970-01-01 00:00:00 UTC
`%S`	second (00..60)
`%t`	a tab
`%T`	time; same as %H:%M:%S
`%u`	day of week (1..7); 1 is Monday
`%U`	week number of year, with Sunday as first day of week (00..53)
`%V`	ISO week number, with Monday as first day of week (01..53)
`%w`	day of week (0..6); 0 is Sunday
`%W`	week number of year, with Monday as first day of week (00..53)
`%x`	locale’s date representation (e.g., 12/31/99)
`%X`	locale’s time representation (e.g., 23:13:48)
`%y`	last two digits of year (00..99)
`%Y`	year
`%z`	+hhmm numeric time zone (e.g., -0400)
`%:z`	+hh:mm numeric time zone (e.g., -04:00)
`%::z`	+hh:mm:ss numeric time zone (e.g., -04:00:00)
`%:::z`	numeric time zone with : to necessary precision (e.g., -04, +05:30)
`%Z`	alphabetic time zone abbreviation (e.g., EDT)

By default, date pads numeric fields with zeroes. The following optional flags may follow %:

Systemd

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

A suite of basic building blocks for initalizing and managing a Linux system.

Units

The basic object that systmed manages is a unit. There are many types, but the most common is a service unit, which we can interact with via the systmectl command.

# start, stop, and restart a service
sudo systemctl start nginx.service
sudo systemctl stop nginx.service
sudo systemctl restart nginx.service
# reload a service's configuration (not unit configuration)
sudo systemctl reload nginx.service
# reload a service's unit configuration
sudo systemctl daemon-reload nginx.service

# get the status of a unit
systemctl status nginx.service

# control whether the service starts on bootup
sudo systemctl enable nginx.service
sudo systemctl disable nginx.service

# get unit information
systemctl list-units

To inspect a unit file, the following commands can be used.

TCP

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

Transmission Control Protocol is a network communication protocol designed to reliably send ordered data packets over an IP network.

Segment Structure

A TCP segment consists of a TCP header and a data section. There are 10 mandatory fields for the header.

Field	Description	Offset	Size (Bits)
Source port	The sending port	0	16
Destination port	The receiving port	16	16
Sequence number	The initial sequence number (if SYN set) otherwise the accumulated sequence number	32	32
Acknowledgement number	If ACK set, the expectant next sequence number	64	32
Data offset	Size of the TCP header in 32-bit words (min 5, max 15)	96	4
Reserved	For future use (should be set to 000)	100	3
Flags	9 1-bit flags	103	9
Window Size	The size of the receive window	112	16
Checksum	Error checking for the header	128	16
Urgent pointer	If URG is set, offset from the sequence number indicating the last urgent data byte	144	16
Options	Optional header fields	160	0-320

The flags section indicates which fields are relevant in the header. There are 9 total flags.

tmux

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

tmux

tmux is a terminal multiplexer that allows for multiple virtual terminals to be created and controlled from a single screen. tmux may be detached from a screen and continue running in the background, then later reattached.

It is great especially to ssh into another computer for long running jobs or simply have access to multiple terminals from the same ssh connection.

Usage

From the command line, you may start a new session or attach to an existing session like so.

UART

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

Universal Asynchronous Receiver-Transmitter (UART) is a serial communication protocol, usually used in embedded systems. It requires only two wires (plus a common ground). One wire transmits and the other wire receives. Each device controls their transmitter and reads from the receiver. Data is transmitted and received one bit at a time. Common baud rates are 115200 and 9600 bits per second.

Protocol

UART can be configured for different transmissions including parity bits, however the most common configuration is 8-bit frames with no parity. Additionally, data is always sent from least significant bit to most.

V

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

V is a very young compiled language targeting many domains. It’s a very exciting project that has a lot of potential in many domains. I would best describe it as a mix of Rust and Go.

Hello World

println('Hello, World!')

Option and Results

V combines Option and Result into one type, and forces you to handle errors directly at the call site. A variable cannot be an Option type.

fn maybe(n int) ?int {
 if n < 10 {
 return error('expected n >= 10')
 }
 return n
}

// handle with `or` block
n := maybe(5) or {
 panic('error: $err')
}

// handle with default value
n := maybe(5) or { 0 }

// bubble up the error
n := maybe(5) ?

Concurrency

V takes inspiration from Go’s concurrency model from a developer’s perspective, however it uses system threads instead of green threads. There is no V runtime to manage them. V also has some nice thread ergonomics not available in Go.

Veganism

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

Veganism is the practice of abstaining from using animal products, especially in food, but it applies to all parts of life.

Benefits

Eating vegan benefits the animals, environment, and your health and well being. It is a win-win situation where everyone is better off. There are no real disadvantages to eating a plant based diet. The only one I can see is the social pressure. Unsupportive friends or family members can strongly influence your decisions, and they probably are not your real friends if they negatively influence you.

vim

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

vim

Plugins

myusuf3/numbers.vim: Relative line numbering
tpope/vim-commentary: Comment out lines with gc
tpope/vim-surround: Change surrounding characters ('``"``` ```()[]{})with cs[(`
iamcco/markdown-preview.nvim: Render markdown file in realtime with :MarkdownPreview
airblade/vim-gitgutter: Show git diff in the gutter

Default Binds

Bind	Description
`gf`	Goto file. Start editing the file under the cursor.
`gF`	Start editing the file under the cursor and jump to the line number following the filename.
`gd`	Goto definition.
`ga`	Print ASCII value of character under the cursor.
`]p`	Paste line matching indent of current line.
`-af`	Action around function (e.g. `daf` is delete around function)
`-as`	Action around sentence.

Custom Binds

" Semicolon in normal mode is the same as colon
nnoremap ; :

" Escape key also mapped as pushing j and k
inoremap jk <Esc>
inoremap kj <Esc>
autocmd InsertEnter * set timeoutlen=75
autocmd InsertLeave * set timeoutlen=1000

" Split moving
set splitbelow
set splitright
nnoremap <C-L> <C-W>w
nnoremap <C-H> <C-W>W

" Tab moving
nnoremap <C-J> :tabnext<CR>
nnoremap <C-K> :tabprev<CR>

" Format
nnoremap <C-O> !!fmt<CR>

" Goto file will open in new tab
map gf <C-W>gF

WS2812B

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

WS2812B is a control circuit and serial protocol used for controlling LEDs (usually in a strip). It requires only a single wire for data transfer in addition to power (5V) and ground. Each LED is addressable using this protocol as well.

Protocol

Because it uses a single wire, communication is done serially one bit at a time. 24 bits of data is sent for each LED (GRB) in the circuit followed by a reset code. Each circuit consumes the first 24 bits it receives and passes the rest of the data along the line.

x86 Assembly

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

x86 Assembly

x86 (32-bit) and x86-64 (64-bit) assembly is syntactic sugar for machine code that gets executed by a CPU. The two flavors of assembly are intel and att, however intel is much more digestible.

Assembly Introduction Reference

Wikibooks Reference

Registers

There are 16 registers available, 3 of which are special purpose.

rbp: base pointer (points to the bottom of the stack frame)
rsp: stack pointer (points to the top of the stack)
rip: instruction pointer (points to the instruction to be executed)

8 Byte Register	Lower 4 Bytes	Lower 2 Bytes	Lower Byte
`rbp`	`ebp`	`bp`	`bpl`
`rsp`	`esp`	`sp`	`spl`
`rip`	`eip`
`rax`	`eax`	`ax`	`al`
`rbx`	`ebx`	`bx`	`bl`
`rcx`	`ecx`	`cx`	`cl`
`rdx`	`edx`	`dx`	`dl`
`rsi`	`esi`	`si`	`sil`
`rdi`	`edi`	`di`	`dil`
`r8`	`r8d`	`r8w`	`r8b`
`r9`	`r9d`	`r9w`	`r9b`
`r10`	`r10d`	`r10w`	`r10b`
`r11`	`r11d`	`r11w`	`r11b`
`r12`	`r12d`	`r12w`	`r12b`
`r13`	`r13d`	`r13w`	`r13b`
`r14`	`r14d`	`r14w`	`r14b`
`r15`	`r15d`	`r15w`	`r15b`

Segment Registers

Early CPU implementations had special registers for memory segmentation, essentially allowing more addresses than could fit in a single register. The x86-64 architecture does not use segmentation in 64-bit mode, though it is still supported for backwards compatibility. In 64-bit mode, all segment registers are forced to 0 except for FS and GS which allows the OS to use them for special purposes.

XSS

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

XSS is a vulnerability in a website that allows an attacker to inject client-side scripts into web pages viewed by other clients. A common target for this attack is user session cookies.

Types

Non-persistent (reflected) XSS vulnerabilities simply take user input (e.g. via a form query parameter) and uses it as part of the HTML body or other form of evaluation. The attacker can craft a URL containing the attack and send it to the victim.