# I'm Garrit, a generalist software developer.

My interests include...

- Fullstack Development
- System Administration
- Programming Language Design
- Minimalist Software
- Free Software

&emsp;

On my [blog](/posts), I ramble about software and tech-related topics. Check
out my [todos](/todo) if you need inspiration for your next project.

I'm always up for a chat. Feel free to [reach out](/contact), or leave a note in
my [guestbook](/guestbook)!

Pssst! Can you find all [hidden flags](/ctf) on this page?

## Projects

**[sendpasswords.net](https://sendpasswords.net/)**

Simplifies secure password transmission using local encryption and temporary PGP keys.

**[seeking-maintainers.net](https://seeking-maintainers.net/)**

An index of open source projects seeking new maintainers.

**[darktheme.club](https://darktheme.club/)**

The Darktheme Club is a collection of accessible web pages from across the Internet.

**[qbe-rs](https://github.com/garritfra/qbe-rs)**

A Rust crate that seeks to provide a Rust-y representation of QBE IR. It can be
used by compilers for code generation.

**[Antimony Programming language](https://github.com/antimony-lang/antimony)**

A bullshit-free programming language that compiles to JavaScript.


Single Page Applications on GitHub Pages


My latest project, [sendpasswords.net](https://sendpasswords.net/) is a [Single Page Application](https://developer.mozilla.org/en-US/docs/Glossary/SPA) deployed on GitHub Pages.

GitHub Pages is configured in a way to host static HTML files without any bells and whistles. This means that if you try to fetch a document that's *not* the index, for example `/foo`, the server will try to load the file with that name. 

By nature, SPAs only consist of a single HTML entry point (`index.html` in most cases). It's responsible for routing the user to the correct page if there are multiple paths. And here's the crux: if the user tries to load `/foo`, he will not land at the SPA entry point. Instead, he will see a `404` error.

## The solution

A `404` response will automatically return a file called `404.html`, which we can use to our advantage. After building the application, simply copy the `index.html` to `404.html`, as demonstrated by [this commit](https://github.com/garritfra/sendpasswords.net/commit/66bdb68c229a3ac3386f7816a746155e658eb586). This will use `index.html` to serve the application on the root level, and `404.html` to load *the same app* if the page doesn't exist as a file. Whether the `index.html` is needed if there's already a `404.html` is up to you. I left it in to make clear that this is just a workaround.

This is a [well known](https://stackoverflow.com/a/69308662/9046809) workaround, but I wanted to bring some extra awareness to it, since it's a problem I ran into a couple of times so far. Happy SPAing!

---

This is post 069 (nice) of [#100DaysToOffload](https://100daystooffload.com/).


Optimizing work batch size


I've been playing 
[Carcassonne](https://en.m.wikipedia.org/wiki/Carcassonne_(board_game)) a lot with my girlfriend recently. It's a boardgame about building cities, roads and farms, and each completed "project" earns you some amount of points. The twist is that there's only a limited number of tiles, and once all tiles are used, the game is over unfinished projects are discarded.

The first couple of playthroughs I tried to maximize my score by increasing the number of projects I actively had going. I'd start a new city or road whenever I could, thinking that the multipliers you sometimes get would pay off in the end. Boy was I wrong.

Where I'm from, we have multiple sayings for this approach. "Having too many irons in the fire" or "dancing on too many parties". I was too busy starting new projects instead of making actual progress.

A far better approach is to finish projects early, earning less points, but with a greater certainty that they will pay off. With every project you start, the likelyhood of the other projects paying off decreases.

Keeping batch sizes small was a key concept of the [lean manufacturing movement](https://en.m.wikipedia.org/wiki/Lean_manufacturing) in the 1980s, and has since been adopted by the [DevOps movement](https://de.m.wikipedia.org/wiki/DevOps) for the IT industry. If you want to learn more about this topic, you should check out [The DevOps Handbook](https://itrevolution.com/product/the-devops-handbook-second-edition/). It goes well beyond the basics of making IT processes more productive and efficient.

After realizing that small batch sizes are the key to success, I haven't lost a game of Carcassonne since. I hope you're not reading this, honey.🤭

---

This is post 068 of [#100DaysToOffload](https://100daystooffload.com/).


Serverless Framework Retrospective


A current project requires the infrastructure to be highly scalable. It's expected that > 50k Users hit the platform within a five minute period. Regular ECS containers take about one minute to scale up. That just won't cut it. I decided to go all in on the [serverless](https://www.serverless.com/) framework on AWS. Here's how it went.

### Setup

Setting up a serverless application was a breeze. You create a config file and use their CLI to deploy the app.

### The rest of the infrastructure

I decided to define the rest of the infrastructure (VPC, DB, cache, ...) in Terraform. But, since I wasn't familiar with how the Serverless Framework worked, I struggled to draw the line between what serverless should handle vs. what the rest of the infrastructure (Terraform) should provide. In a more traditional deployment workflow, you might let the CI deploy a container image to ECR and point the ECS service to that new image.

I chose to let Serverless deploy the entire app through CI and build the rest of the infrastructure around it. The problem with this approach is that we lose fine-grained control over what's deployed where, which leads to a lot of permission errors.

In retrospect, I should've probably chosen the location of the S3 archive as the deployment target for the CI, and then point the lambda function to the location of the new artifact. This defeats the purpose of the framework, but it gives you a lot more control over your infrastructure. Once the next project comes along, I'll probably go that route instead.

### Permissions

Serverless suggests to use admin permissions for deployments, and I see where they're coming from. Managing permissions in this framework is an absolute mess. Here's what the average deployment workflow looks like, if you want to use fine grained permissions:

1. Wait for CloudFormation to roll back changes (~2 minutes)
2. Update IAM role
3. Deploy Serverless App
4. If there's an error, go to 1

Thankfully, some people have already gone through the process of figuring this out. [Here's](https://serverlessfirst.com/create-iam-deployer-roles-serverless-app/#determining-deploy-time-permissions) a great guide with a starting point of the needed permissions.

### Conclusion

Using the serverless framework is a solid choice if you just want to throw an app out there. Unfortunately the app I was deploying isn't "just" a dynamic website. The next time I'm building a serverless application it's probably not going to be with the Serverless Framework, though I learned a lot about serverless applications in general.

---

This is post 067 of [#100DaysToOffload](https://100daystooffload.com/).






Migrating Homeassistant from SD to SSD


I finally got frustrated with the performance of my Raspberry Pi 4 running Homeassistant on a SD card, so I went ahead and got an SSD.

The migration was **very** easy:

1. Create and download a full backup through the UI
2. Flash Homeassistant onto the SSD
3. Remove the SD card and plug the SSD into a USB 3.0 port of the Pi
4. Boot
5. Go through the onboarding procedure
6. Restore Backup
7. Profit

It worked like a charm! The speed has improved A LOT, and everything was set up as it should be. 

...Until we turned on the lights in the livingroom. My ZigBee-dongle, plugged into another USB port, wasn't able to communicate with the devices on the network.

After some digging around, I came across several threads stating that an SSD over USB 3.0 apparently creates a lot of interference to surrounding hardware, including my ZigBee dongle. The fix was simple: either get an extension port for the dongle, or plug the SSD into a USB 2.0 port of the Pi. Since I didn't have an extension cord to get the dongle far away enough from the SSD, I went with the latter option for now. And that fixed it! The performance was much worse, but still better than the SD I used before. My next step will be to grab an extension cord from my parents. I'm sure they won't mind.

I hope this helps!

---

This is post 066 of [#100DaysToOffload](https://100daystooffload.com/).







The role of a DevOps Engineer


The term "DevOps" can be interpreted in many different ways. It's often thrown around as a buzzword whenever somebody is talking about "what comes after development". Obviously, it's not just that. Or is it? It depends on whom you're talking to.

Although I just recently started my new role as a "DevOps Engineer", I'm still discovering what that term means to me. I just had a fruitful conversation with the DevOps lead of a client, and they phrased this role in a very fitting way.

> A DevOps Engineer doesn't push the button, they enable the developers to push the button themselves.

To me this role is fascinating, since it touches so many different aspects of software delivery.

---

This is post 065 of [#100DaysToOffload](https://100daystooffload.com/).


I'm Garrit, a generalist software developer.

Projects

Recent posts