Brennen Puth

Using Hashcat (with a Nvidia GPU) on a bootc system

bputh.blog@gmail.com (Brennen Puth) — Fri, 06 Feb 2026 00:00:00 +0000

This is intended as a future reference, for myself and anyone else who runs into issues. I have a Nvidia 3060Ti in my desktop, and this is how I got hashcat working with it.</p>

Symptom</h2>
`hashcat</code> installed via brew</code> cannot use the Nvidia GPU. On further inspection, even clinfo</code> cannot see the Nvidia GPU.</p>`

Solution</h2>
TL;DR: Use a container!</p>
Step 1</h3>
Set up podman for Nvidia GPUs</a>.</p>
Step 2</h3>
Create a container which has Nvidia integration.
The one I chose to use is dizcza/docker-hashcat</a>, which includes hashcat</code> and provides images for all the types of GPUs. The tag I'm interested in is cuda</code>.</p>
My strategy was to use distrobox</code> to set up nice host integration. Use the following commands.</p>
distrobox create --nvidia --image dizcza/docker-hashcat:cuda hashcat
distrobox enter hashcat
# Inside the container
distrobox-export /usr/local/bin/hashcat
</code></pre>
Alternatively, use the below distrobox-assemble</code> config.</p>
[hashcat]
image=dizcza/docker-hashcat:cuda
nvidia=true
init=true
start_now=false
unshare_all=true
exported_bins="/usr/local/bin/hashcat"
additional_packages="systemd"
</code></pre>
Step 3</h3>
Use hashcat</code> as you normally would from your host system!  distrobox</code> should take care of exporting the binary such that it's available to your terminal.</p>

Hopefully these steps helped.  If they didn't work, shoot me an email</a> and I'll see what I can do to help!</p>



Why so many notifications, Google?
bputh.blog@gmail.com (Brennen Puth) — Thu, 08 Jan 2026 00:00:00 +0000
Occasionally I have to collaborate with myself via Google.
Either I create the document on the wrong account or I share it with another account for easy access.
Whatever the case, Google sends an absurd</em> number of notifications when you share something with someone.
I created and shared a test document to count.</p>
Two for my email (one for computer, one for phone, which is alright if it was the only thing)...</p>
</p>
one through Google Chat...</p>
</p>
and one through Google Drive.</p>
</p>
Why on earth do I need to know in so many ways about this one event?
Particularly, why am I by default</em> recieving communications on Google Chat, which I do not use?
I can luckily uninstall the Google Chat plugin to get rid of one of the notifications.
Google Drive and Gmail however I do not want to turn off notifications for. The former has too few to bother, the latter contains important information most of the time.</p>
I've noticed this is characteristic of many software suites. Lots of notifications about the same event, through several different channels. This is an especially insidious problem when connecting two software suites (Todoist and Google Calendar, Outlook and Webex). It's not usually either platform's fault but a user configuration error.</p>
I wonder if there's a better way to unify notifications for a single piece of information...</p>


Connecting to eduroam with NetworkManager on the CLI
bputh.blog@gmail.com (Brennen Puth) — Fri, 12 Dec 2025 00:00:00 +0000
I decided to set myself up with Zirconium</a> yesterday on my Framework 13.
When I booted into Aurora (my chosen image to rebase from) I got the wifi working immediately.
When I booted into Zirconium after switching, the wifi no longer worked.</p>
When trying to connect manually via nmtui, it would give me a message along the lines of "AP security could not be confirmed" and stop connecting.
Other, non-enterprise networks worked fine.
To fix this, I finally found this post</a> which describes how to connect to eduroam using nmcli</code>.</p>
The steps are as follows:</p>


Find your network adapter with ip link</code>.</p>
</li>

Create the connection with nmcli con add type wifi con-name "eduroam" ifname $INTERFACE ssid "eduroam" wifi-sec.key-mgmt wpa-eap 802-1x.identity "$USERNAME" 802-1x.password "$PASSWORD" 802-1x.system-ca-certs yes 802-1x.eap "peap" 802-1x.phase2-auth mschapv2</code>.  Replace $USERNAME</code> and $PASSWORD</code> with the connection details you would use when connecting through a GUI.  Replace $INTERFACE</code> with the WiFi interface you found in step 1.</p>
</li>

Bring the connection up with nmcli connection up eduroam --ask</code>.</p>
</li>
</ol>


Programmer Things That Aren't Building The Project
bputh.blog@gmail.com (Brennen Puth) — Mon, 01 Dec 2025 00:00:00 +0000
Written as an extension to things that aren't doing the thing</a></em> because there are a lot of things that I tend to think are building the project which are in reality not building the project1</a></sup>.</p>
Naming the project is not building the project.</p>
Fixing your broken Arch install is not building the project.</p>
Considering how your project fits with other projects is not building the project.</p>
Writing a blog post about how the project could be done is not building the project.</p>
Wondering how your project will be received is not building the project.</p>
Choosing a language is not building the project.</p>
Configuring your dev environment is not building the project.</p>
Running an initialization command (cargo new</code>, or npm init</code>, or go mod init</code>, or any other) is not (yet) building the project.</p>
Letting a LLM run wild on your project is not building the project2</a></sup>.</p>
Scanning for micro-optimizations in the project is not building the project.</p>
All of these things may at some point be part of the project. You will know when. Most days, they're little distractions while I avoid building the project for the first time.</p>

^{1</sup>
I might do another one of these, when I've built more projects. I think of a lot of things as I build the project to avoid building the project.</p>
</div>
^{2</sup>
Sorry, couldn't help myself. It might be building the project, but you're not going to convince me it's building the project you should be proud of.</p>
</div>}}


Local Digital Economy
bputh.blog@gmail.com (Brennen Puth) — Wed, 29 Oct 2025 00:00:00 +0000
Over the summer, some friends and I read this essay</a> about local communities by Wendell Berry. We also read his book named Jayber Crow which exemplifies the same values in the life of a character. His observations of a centrifugal force which pulls people into a city and kills any small country town nearby sounds eerily similar to the effect of large social media platforms on the Internet. These large platforms draw you in and entice you to stay. This kills smaller digital spaces, because it is easier to visit one place and see everything you want rather than visit five to ten places all of which may or may not be immediately pleasurable.</p>
I am unfortunately too young to have seen the Internet in its early days. From what I have heard, reading various blogs of lament, the Internet started out similar to the American countryside of Berry's description1</a></sup>. A connected group of small towns, each of them offering a few of the services you need. Anything not in your town can likely be found by taking one of the roads to the next town over. A hyperlink is the digital space equivalent to a road2</a></sup>. I would call the collection of digital spaces and hyperlinks the geographic digital map.
Each road you create from your space to another location provides your viewer an option, to stay where they went or to return to the source of the link. If you send them to a place designed to capture their attention, all you can expect is that one day they won't choose to come back.</p>
I think our culture is finally realizing the effects of creating hyperlinks to cities, in one way or another. I have read several blog posts which are a call to revive the old Internet, where websites were run by small groups or individuals. Each space had its own culture and its own style, a way of acting which was unique to itself and the people who made up the space. This has seen some level of traction, especially with programmers like myself who desire the freedom to just write HTML. Substack as a platform espouses this value by giving each creator their own blog area on the website, although it still has an algorithmic feed so it loses points for that. In any case, the question I'm asking is: How do we stop people from moving to the cities, and revive the older Internet?</p>
One of Berry's central ideas in the essay is that to have local community, you must have local economy. On the Internet, the economy consists of both regular old currency and more importantly the currency of attention. In some sense, even though I put no ads on my blog and thereby have no monetary gain from it, I am participating in the economy by holding the attention of you, the reader. You're welcome. Hopefully I shouldn't have to prove the attention economy too much, our culture has been buzzing with the idea3</a></sup>.
In order to recapture the local communities of people on the internet, we must do our best to keep the economy local.</p>
The issue with local economy on the Internet becomes finding the local communities as a traveler. This is quite analogous to visiting a new country for the first time.
Say I want find a small town in England. I don't have much knowledge of England, so I'll go find a map.
This is what Google gives for a quick search of "England map".</p>

Observing this map, I can clearly see the large cities, but it won't help me find a smaller town. Using Google for searching the Internet map creates a similar feeling. A generic search query usually only turns up the cities of the Internet. Refining my search query to around a specific area, say, around Leeds, I'll quickly find some of the smaller towns. Unfortunately, search engines don't quite mimic the real-life map. Speaking from personal experience, a refined query leads to a whole bunch of SEO-optimized websites and AI overviews trying to grab my attention still.
I have a few thoughts about how the Internet map can be made more useful, especially around these smaller communities.</p>
As a maintainer of a digital space, I want to focus on keeping viewers on a smaller network of sites which aren't designed to optimize the attention economy, including but not limited to my own. One of the best strategies I've seen for this is a webring</a>. A webring links a whole bunch of similarly minded sites together forming a community. Unfortunately, I'm not yet cool enough to be in one4</a></sup>. If each website represents a person, or maybe even a business, a webring would represent a town. A town would be just a bunch of shops who have agreed to be near each other for convenience, without any governing power other than the community around them (and perhaps a sheriff, if the community deems it necessary). This seems to me the easiest way forward to create roads between smaller websites and blogs, and gather them into the equivalent of a local map. Keeping the economy of attention inside the webring builds the community.</p>
As a viewer, my hope to run from the city and invest in small communities. My personal strategy for this is to use a RSS reader to keep tabs on my favorite blogs, where I have to intentionally go out of my way to subscribe to someone if I want to hear from them. Furthermore, I send a message through their platform if I have questions. I also might subscribe to a webring, if I want to hear from all sorts of creators in a topic area. Other strategies I've tried are blocking algorithmic feeds and sometimes even removing the ability to access the city-size websites entirely.</p>
All of that written, I'm still learning and working on it myself! I want to continue considering better strategies to steward my digital spaces, especially including this blog. If this article made you think of anything else that could be done to structure online spaces to foster the feeling of local community, my inbox is open</a>. Also, definitely check out the essay linked at the beginning of the article if you're interested in further understanding the idea. Berry writes with a clearer voice than I know how to.</p>

^{1</sup>
Could be wrong. Again, I wasn't lucky enough to have seen it. Let me know!</p>
</div>
^{2</sup>
I am tempted to use the word "place" here, but jury's still out for me on whether a "digital place" is a real thing.</p>
</div>
^{3</sup>
See media such as The Social Dilemma gaining a lot of traction.</p>
</div>
^{4</sup>
Maybe I'll start my own! The internet is full of possibilities.</p>
</div>}}}}


The Fake Social Binary
bputh.blog@gmail.com (Brennen Puth) — Sat, 13 Sep 2025 00:00:00 +0000
A few years ago, my friends and I decided to have a weekly movie night. Now, since we're all at college and living in dorms less than a 10 minute walk from each other, that was pretty easy.
At the beginning, we simply told each other during the day the plans for that night. That way, we don't have to think that hard about it until the day of.
Of course, eventually others heard about this weekly rhythm, and were slowly invited to join us for it. The issue is, word of mouth doesn't scale very well in our culture.
Therefore, someone creates The Group Chat. The Group Chat contains everything you need to know about our circle of friends, especially the information about this weekly rhythm. We all love The Group Chat, because what used to be a fraught process where people might be accidentally left out now by default includes everyone.</p>
And then people continue to be added to The Group Chat. This happens in several ways, although the all-time hits usually include "You're coming tonight? Let me add you to The Group Chat!" and "I'll just invite _____ to The Group Chat, it'll be easier that way."
Platforms particularly seceptible to this have the (honestly nice) feature of adding someone to an existing chat, although platforms without that feature are not excluded.
One day, I woke up and realized my small social gathering of friends has now grown to a almost corporate production, where a movie is played every week.
The movie-watching group has grown immensely, and the post-movie time usually feels more akin to leaving class than to friendly community.
I never know who might come to any given event, nor do I particularly care. The activity is the center of the event, not the people I am with.</p>
Throughout this experience, I understood deeper how community works, and specifically how technology has broken it.
There are so many thoughts which race through my head on this topic, but I'll restrict myself to one road for today.</p>
Problem</h2>
Computers work using 1s and 0s. On or off. A binary system.
Humans are "squishy". They have friends for one task, but don't necessarily always want them around. Opinions drift over time.
Why do we treat humans as if they will perfectly map onto computers?</p>

"The map is not the territory" - Alfred Korzybski</p>
</blockquote>
Pulling on the thread of common sense, a finite number of 1s and 0s cannot accurately represent the ability of a human to think. (I believe that would be impossible entirely, but hopefully all can agree we're not there yet</em>.)
As a programmer, I hope to be making good representations of reality knowing this is true.
Since I cannot perfectly represent the territory (human conversation) on the map (computer), I should be considering which capabilities I need in order to represent the important parts, hopefully cheaply.
The rest of this post shifts to look at which features I think have mapped technology well, and which ones are conveniences that don't actually fit the reality of the territory.</p>
Observations</h2>
Quick Replies</h3>
I can give a quick yes or no to my friend. This is my #1 use for instant messaging, where I just need to communicate a quick detail or fact.
Maps to real life decently well, because it's similarly quick to send a yes or no message to a friend in person.  This usage mostly just shortens the feedback loop.</p>
Announcements</h3>
While not everyone can write a good announcement, those who can do a masterful job of keeping their community informed.
In the case of my movie-watching group earlier, when the group got big, messaging systems worked significantly better which is not particularly a downside.
Even beyond the benefits of instantly sending the announcement to everyone, anyone can go back and re-read the message to make sure of what you said. Much better than word of mouth where memory is concerned, especially in this age where we've lost that power.</p>
Asynchrony</h3>
Since time immemorial, humans have been writing down things so that other humans can read them later.
Even better, so that other humans can respond to them later.
Instant messaging gets this perfect. No one has to worry that they asked the question hours ago, someone can still get back to them when they have time.
The efficiency of posting allows more than one question to be asked, just like in real life.  Some people are not quite fluent with the keyboard, but that seems similar to real life as well.</p>
Overbearing Access</h3>
At all times, I can text my friend and know he will recieve. The speed and reliability of the medium mean I can make no excuses for my friend ignoring my text, except that he may be bad at checking his phone.
This doesn't map real life at all, except by a simulation of being nearby another person. A short-range conversation, this exactly replicates what's happening. A long-distance communication, there will always be some risk involved that my message won't reach the recipient.
This is in the neutral category because the answer is that it depends on what sort of interaction you want to mirror.</p>
Incomplete Interaction</h3>
Lots of information is lost in transport when it comes to messages. The same holds for any written communication, meaning this one maps fairly well and I don't have much to say about it.
We've found ways to deal with this in our written-first world. Emoji come to mind, along with the wonderful tone indicators such as /s</code> and /lh</code>.</p>
Lack of Drift</h3>
For good reason, friendships form and dissolve all the time. If the solution to tracking this change is to kick people out (unusual in real life under non-toxic circumstances) or create a new group (usually high friction), you'll have a hard time mapping this to real life.
This is the one category for which I have an experiment I want to try. Perhaps, one could create a social service where no group chats will stick around, making The Group Chat impossible to create. Of course, one would need a full text search of good quality, which sounds like a fun challenge to me.
Ignore my digression into solutions though, and consider that reducing the friction to tracking these drifting changes in my opinion is the best way to solve this natural drift.</p>
Conclusion</h2>
My words are neither exhaustive nor inerrant - I deeply hope that this will spark some discussion and perhaps begin to push the needle toward a human-centric design for instant messaging.
I also hope that, even if you disagree with me on every point or think I wrote this poorly (to which I say, you're probably right), you'll use this as an opportunity for reflection on how you use these chat systems and how they influence the relationships you care about most.</p>


bpOS: Why and how I made my own bootable container
bputh.blog@gmail.com (Brennen Puth) — Wed, 06 Aug 2025 00:00:00 +0000
I previously ran primarily Arch on all my systems.
I don't think that it was particularly thoughtful on my part, I followed the "cool kids" of Linux.
Experiences of breakage were rare for me, but I realized I was doing too much playing sysadmin on my own computer.
In the rare occasion something broke I was never sure whether the failure was on the hardware's part or the software's, which cost me a day of debugging.
Granted, I enjoyed that debugging some, but I don't have the time to assess failures on my computer and</em> reliably do productive work on it.
The secondary problem I found was the setup time.
If Arch requires a reinstall, better hope you wrote a script, because getting everything the way you like it again is otherwise costs hours.</p>
After a particularly bad breakage, someone pointed me to the Universal Blue project.
If you're unfamiliar, they provide bootable containers.
Bootable containers give you the experience of a Docker container on the desktop.
If something breaks on the image, you can always go back to the last version without an issue, all your data stays safe.</p>
Universal Blue provides images for KDE and GNOME, which was fine for testing but I much prefer my tiling window manager for daily use.
Luckily, their frontpage</a> mentions the awesome power of the technology they build upon.
Anyone can create their own custom operating system image, and it takes less than 30 minutes to set up (assuming a base level of familiarity with the CLI and Git).</p>
So, I built my own image.
The source is here</a>, although honestly it's not that interesting.
Which is exactly how I wanted it, because the more boring my image setup is, the less work I'll have to do.
I haven't had a single day where my computer breaks entirely yet, because if it ever breaks, I just roll back to the last deployment (or, if it doesn't boot, it does that itself).</p>
Quick sidenote to mention, desktop files are awesome, and now that I have a proper place I can store them, I will be making far</em> more.
I now have all sorts of shortcuts that I can launch right from my desktop with my application launcher.
If you look in the repository, you'll see I have a few set up for different web services I use.</p>
I really don't have that much more to say about all of this, I just hope some more people take a look at the awesome work all the members of Universal Blue are doing, and this is my encouragement to continue on for all of them.
If you want to check out their images for yourself, their website</a> is a good place to start.
If you want to build your own image like I have, check out the image-template</a> repository they set up.</p>
P.S. If you think this is awesome too and want to get involved, contributing is super</em> easy.  Documentation, code, even just support are all great ways to help out, and the community loves to welcome new contributors in good faith.</p>


Smart Window Resizing in Neovim
bputh.blog@gmail.com (Brennen Puth) — Sat, 12 Apr 2025 00:00:00 +0000
The last day or two, I've been refitting my Neovim windowing config.
Nothing too wild, just fixing a few warts here and there.
What follows is a few different snippets for different behaviors I wanted.
Hopefully one of these is useful to someone, even if only as a reference (something definitely</em> needs said about the Neovim documentation searchability situation).
If you want to see these in their context, links will be left below each example.
The links may fall out of date, so I've linked them to the specific commit.</p>
Also, if you're interested in this, I credit chrisgrieser</a> who used to run a blog called Nano Tips For Vim, which was immensely helpful to me in figuring out all of my Neovim configs but was sadly taken offline as of 2025-06-12.</p>
Turn Off Line Numbers for Small Windows</h2>
1</td> local set_numbers = function(value, window)
</td></tr>
2</td> 	vim.api.nvim_set_option_value("number", value, { win = window })
</td></tr>
3</td> 	vim.api.nvim_set_option_value("relativenumber", value, { win = window })
</td></tr>
4</td> end
</td></tr>
5</td> local window_size_threshold = 40
</td></tr>
6</td> 
</td></tr>
7</td> vim.api.nvim_create_autocmd("WinResized", {
</td></tr>
8</td> 	callback = function()
</td></tr>
9</td> 		for _, win in ipairs(vim.api.nvim_list_wins()) do
</td></tr>
10</td> 			local width = vim.api.nvim_win_get_width(win)
</td></tr>
11</td> 			if width < window_size_threshold then
</td></tr>
12</td> 				set_numbers(false, win)
</td></tr>
13</td> 			else
</td></tr>
14</td> 				set_numbers(true, win)
</td></tr>
15</td> 			end
</td></tr>
16</td> 		end
</td></tr>
17</td> 	end,
</td></tr>
18</td> })
</td></tr></tbody></table></code></pre>
See it in context!</a></p>
Bring Window Into Focus</h2>
1</td> local win_focus = function()
</td></tr>
2</td>     -- Uncomment if you use either of these plugins
</td></tr>
3</td> 	-- require("dapui").close()
</td></tr>
4</td> 	-- require("nvim-tree.api").tree.close()
</td></tr>
5</td> 
</td></tr>
6</td> 	local current_win = vim.api.nvim_get_current_win()
</td></tr>
7</td> 	local windows = vim.api.nvim_list_wins()
</td></tr>
8</td> 	vim.api.nvim_win_set_width(0, vim.o.columns - (#windows * 20))
</td></tr>
9</td> 	for _, win in ipairs(windows) do
</td></tr>
10</td> 		if win ~= current_win then
</td></tr>
11</td> 			vim.api.nvim_win_set_width(win, 20)
</td></tr>
12</td> 		end
</td></tr>
13</td> 	end
</td></tr>
14</td> end
</td></tr>
15</td> 
</td></tr>
16</td> keymap("n", "<leader>rs", function()
</td></tr>
17</td> 	vim.api.nvim_win_set_width(0, 20)
</td></tr>
18</td> end)
</td></tr>
19</td> keymap("n", "<leader>rf", win_focus)
</td></tr></tbody></table></code></pre>
See it in context!</a></p>
Resizing Mappings</h2>
This requires the winresize.nvim</a> plugin.</p>
1</td> local win_resize = function(win, amt, dir)
</td></tr>
2</td> 	return function()
</td></tr>
3</td> 		require("winresize").resize(win, amt, dir)
</td></tr>
4</td> 	end
</td></tr>
5</td> end
</td></tr>
6</td> 
</td></tr>
7</td> wk_add("<leader>r", "Window Resize")
</td></tr>
8</td> keymap("n", "<leader>rh", win_resize(0, 10, "left"))
</td></tr>
9</td> keymap("n", "<leader>rj", win_resize(0, 3, "down"))
</td></tr>
10</td> keymap("n", "<leader>rk", win_resize(0, 3, "up"))
</td></tr>
11</td> keymap("n", "<leader>rl", win_resize(0, 10, "right"))
</td></tr>
12</td> keymap("n", "<leader>r=", "<C-w>=", { desc = "Equalize Windows" })
</td></tr></tbody></table></code></pre>
See it in context!</a></p>


Thoughts on Teaching Text Editing
bputh.blog@gmail.com (Brennen Puth) — Wed, 19 Mar 2025 00:00:00 +0000
Why?</h3>
A friend recently asked me the question that's been around since the dawn of editors: "Is it best to teach someone programming with a pure text editor or with an IDE?"
There is some bias to the formation of the question.
No one who did not believe a text editor was objectively better for one reason or another would ask it with that wording.
In response, I tried to take a reasonable position allowing both IDEs and text editors for teaching.
Our short discussion spawned another in my opinion more interesting question in my mind, however.</p>
What editing tools should</strong> be taught to programming students?</p>
How?</h3>
My mind immediately cries out that they should start with the basics.
Nothing but a empty Vim buffer and a small cheatsheet for whatever language they're being taught first.
Then, they learn the fundamentals of exactly which character goes where, and they have a deep understanding of the syntax.</p>
Wait.</strong> Of the syntax</em>?</p>
Perhaps I'll write up my full opinions on this later, but suffice it to say for now that syntax should not be the goal of teaching programming.
Of course, you need a framework, so you teach someone how to express something in syntax.
I'm not insane enough (yet) to propose a pure pseudocode curriculum, and besides, that would only swap one sort of syntax for another.</p>
What I want is for the syntax and design of the language not to get in the way of learning.
Unfortunately, there is no way around syntax at a fundamental level.
At some point the language must be in the learning programmer's way, and I don't think that's a bad thing.
So if we can't improve the language, the tooling is the next best thing.
I believe there exist a few tools which both do not inhibit learning and are ubiquitous among languages (unless you write your own, I suppose).</p>
In-Editor Code Analysis</h4>
I can hear the comments now. "You've practically just allowed an IDE!"
Look. There comes a time to make people watch their syntax carefully as they write it.
It's not while you're learning how a computer thinks.</p>
The faster the feedback loop, the better the learning.
The amount of people I've helped who waited to compile until they were done typing a whole bunch of incorrect code, simply because compiling takes a lot of keystrokes, is insane.
While teaching "compile and test often" is good, it should not take 20 keystrokes to check your syntax is right</em>.</p>
Code Formatter</h4>
Cedarville (where I'm getting my bachelors), at the very least, has a C++ and Java programming format policy.
I highly appreciate the effort.
Only, code formatters solved that problem a while ago.
There's an opinionated formatter for basically every commonly taught language, and it should be standard to leave most of the formatting to it.</p>
Some examples in modern (and not modern) programming languages:</p>

clang-format</a> for C++.</li>
rustfmt</a> for Rust.  It's inbuilt into the Rust install, anyways.</li>
black</a> for Python.</li>
Go just has a inbuilt command</a>. No need to even install anything.</li>
</ul>
I omitted Java, because there is no good argument for not using a Java IDE, which should come with all of the tools I mention here and more.</p>
The point is, formatting is something to give to tools.
Standardize a config for your clang-format, not a formal specification document (specifically in the context of teaching).
Especially when languages have begun to bundle these sorts of tools, it's absolutely silly to insist that your format is better.</p>
From a teaching and grading perspective, the formatters also can help.
Most of these tools also have a validate mode to ensure the input code is already formatted.</p>
Code Formatter, pt 2</h4>
A tool which closes a bracket for you, or maybe spaces out your brackets as you hit Enter</code> instead of afterwards.
This is something I went without for a while on my Neovim config, and it was incredibly painful.</p>
</p>
^{Credit XKCD for the image.</sup></p>}
An Ending</h3>
I consider this document to be a "standard of living" for a new programmer.
Vim and Vim alone is a terrible strategy when we have tools to help.
So long as those tools teach good behavior and get out of the programmer's way as much as possible, I see no reason not to use them.</p>
I will admit, it's also a personal preference.
Helping people who don't format their code nicely until they submit pains every programming instinct I have.</p>


590 Thousand If Statements, For the Web
bputh.blog@gmail.com (Brennen Puth) — Sun, 11 Aug 2024 00:00:00 +0000
This post was almost entirely inspired by Andreas Karlson's blog post</a> where he details how he created the worst version of an isOdd</code> function ever to visit this land.
Andreas's 4 billion if statements cover the whole of 32-bit integers, and ultimately were written in Assembly to avoid compiler limits from C++.
Of course, when I saw this post, I wondered, how crippled would a browser be to read a 4 billion if statement WASM program?</p>
I started my exploration in a similar way: I attempted to write a Rust program that compiled to WASM for the simplest solution.
Using a Python script to generate the if statements, I used the first wasm-pack base I found and gave Rust a shot.
This went well for smaller numbers (under 2^20 or so).  After reaching 2^20, the Rust compile times became absurdly long.
The file with 2^8 if statements compiled in about 10 seconds.  The file with 2^16 took about 8 minutes.
When I tried the file with 2^24 if statements, the Rust compiler still tried, but ultimately I had to go to bed and shut it down after about three hours.
This isn't too surprising, since the Rust compiler is optimized for safety, but I did want a WASM file with 4 billion if statements before the end of the millenia still.</p>
When Rust took too long, I decided the C/C++ to WASM route was probably also improbable for the same reason as in the original rendition.  The compiler won't like a 330GB code file.
I may also have decided this because I really wanted to mess with writing binaries, but that's not the point here.
The point here is that the plan was to write the WASM by hand.</p>
Since I didn't have any prior experience with working with binary formats, I started by compiling a simple WASM program which did a single comparison, and parsed that in order to understand what was going on.
With a single if statement, I was able to begin understanding the binary format.  Here's the quick explanation:</p>
WASM files all start with the following bytes, the first four are a special sequence (equivalent to \0asm</code>) and the latter four are a version number.  WASM is on version one at the time of writing.</p>
00 61 73 6D 01 00 00 00
</code></pre>
The next step is the types section.  Quick detour about sections, every one starts with a id and then a LEB128 encoded number</a> which defines the length of the section.
The type section has an id of 3</code> and will contain a single function type, taking a i32 parameter and returning a i32.  Booleans in WASM are represented by i32, returning a 0</code> or 1</code>.</p>
01 06 01 60 01 7F 01 7F
</code></pre>
I won't go too far into the details of the type here, you can take a look at the WASM instruction list</a> yourself if you get curious.</p>
The function also has to be defined separately in the function section, which is simple enough.</p>
03 02 01 00
</code></pre>
To translate, we are declaring we are in section id 3, giving it a length of 2, and reporting which types the function has in the func section of the module.
I don't fully understand this bit either, don't worry.  All that's important here is that the compiler expects it.</p>
Finally, the function needs a name, given in the export section.  This is also the section that makes the function available from JavaScript.</p>
07 09 01 05 69 73 4F 64 64 00 00
</code></pre>
The gist of this one is that the ASCII for the function name isOdd</code> is encoded into the bytes of the section.</p>
All of this can come together into a simple Python script to write the preamble for our code.</p>
1</td> filename = 'isodd.wasm'
</td></tr>
2</td> 
</td></tr>
3</td> start_bin = bytes([0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00,
</td></tr>
4</td>                    0x01, 0x06, 0x01, 0x60, 0x01, 0x7F, 0x01, 0x7F,
</td></tr>
5</td>                    0x03, 0x02, 0x01, 0x00,
</td></tr>
6</td>                    0x07, 0x09, 0x01, 0x05, 0x69, 0x73, 0x4F, 0x64, 0x64, 0x00, 0x00,
</td></tr>
7</td>                    0x0A])
</td></tr>
8</td> 
</td></tr>
9</td> with open(filename, 'wb+') as f:
</td></tr>
10</td>     f.write(start_bin)
</td></tr></tbody></table></code></pre>
The final 0A</code> byte is to start the code section.</p>
With all that tedious work out of the way, now comes the fun part.  Unlike in raw Assembly, the resulting WASM file is exporting a function.  WASM doesn't have anything to the effect of return true</code> that we can use.
The easy version of the code in a sane language would've looked like this.</p>
if (x == 1) return true;
if (x == 2) return false;
...
</code></pre>
Instead, WASM forces us into a paradigm that looks more like this.</p>
if (x == 1) return true;
else {
    if (x == 2) return false;
    else { ... }
}
</code></pre>
This isn't a huge issue, but it forces a slightly different code structure where we have to end all of those else statements at some point.</p>
The other issue is that we can't have all 4 billion if statements in memory at once, or my Linux environment likes to freeze up and kill the process.  Instead, we write byte by byte appending into the file.
This doesn't seem like an issue until you remember that we don't really know how long the code is until we generate it, and I don't want to go back and write into a specific byte of the file because I'm lazy and don't feel like it.
We'll solve that issue later, though, and just focus on getting the code written for now.  I'll pretend I have it solved by making a variable and dealing with it later.</p>
function_size = 32 # This is incredibly wrong
</code></pre>
For the actual code part, the concept is simple.  WASM is a stack-based language, which means you do operations by pushing values onto the stack.
To do the simple comparison (if (x == 1)</code>), it takes four steps.  First, grab the local variable (x</code>) with the bytes 20 00</code>, 20</code> meaning get a local variable, and 00</code> being the first one.
Second, push the constant value to compare with onto the stack with 41 ??</code>, 41</code> being load constant and ??</code> being our number to load.  The number is encoded in LEB128 format, which will make life a little harder later, but not much.
Third, compare the two and leave that value on the stack with 46</code>, which is the instruction for ==</code> in WASM.
Fourth, the if statement is represented with 04 7F</code>, with 04</code> being the if and 7F</code> being the return type of i32.
Fifth, to write our code inside this if statement, 41 ??</code> returns whether the value resulted in true or false.
Finally, the end of the if statement is capped off with a else</code>, with 05</code>.</p>
The only thing left to do then is create one more branch for anything that doesn't fit these values, and cap off all those if statements with end statements.
The full code for all of this is below.</p>
1</td> with open(filename, 'ab') as f:
</td></tr>
2</td>     # section size
</td></tr>
3</td>     f.write(leb128.u.encode(function_size + 1 + len(leb128.u.encode(function_size))))
</td></tr>
4</td>     # locals passed
</td></tr>
5</td>     f.write(bytes([0x01]))
</td></tr>
6</td>     # function size
</td></tr>
7</td>     f.write(leb128.u.encode(function_size))
</td></tr>
8</td>     # no-op
</td></tr>
9</td>     f.write(bytes([0x00]))
</td></tr>
10</td> 
</td></tr>
11</td>     for i in range(0, limit):
</td></tr>
12</td>         # local.get 0
</td></tr>
13</td>         f.write(bytes([0x20, 0x00]))
</td></tr>
14</td>         # i32.const i
</td></tr>
15</td>         f.write(bytes([0x41]) + leb128.u.encode(i))
</td></tr>
16</td>         # i32.eq
</td></tr>
17</td>         f.write(bytes([0x46]))
</td></tr>
18</td>         # if (return i32)
</td></tr>
19</td>         f.write(bytes([0x04, 0x7F]))
</td></tr>
20</td>         # if block
</td></tr>
21</td>         f.write(bytes([0x41]) + leb128.u.encode((i) % 2))
</td></tr>
22</td>         # else
</td></tr>
23</td>         f.write(bytes([0x05]))
</td></tr>
24</td>         # else block is the next if
</td></tr>
25</td> 
</td></tr>
26</td>     f.write(bytes([0x41, 0x02]))
</td></tr>
27</td> 
</td></tr>
28</td>     for i in range(0, limit + 1):
</td></tr>
29</td>         f.write(bytes([0x0B]))
</td></tr></tbody></table></code></pre>
Now it is time to return to the issue earlier of figuring out the code size before we've written the code.  Turns out, this is a simple enough problem to solve iteratively, and since I'm lazy, I did that.
There might be a smarter mathematical way of doing this.</p>
1</td> function_size = 4
</td></tr>
2</td> for i in range(0, limit):
</td></tr>
3</td>     function_size += 10
</td></tr>
4</td>     if i != 0:
</td></tr>
5</td>         function_size += 1 + math.floor((math.log2(i)) / 7)
</td></tr>
6</td>     else:
</td></tr>
7</td>         function_size += 1
</td></tr></tbody></table></code></pre>
The reason for the math.floor</code> bit is because of the LEB128 encoding.  Every time the number grows by 7 powers of 2, it gains an extra byte of code size per if statement.</p>
After all this, I finally have a Python script capable of writing the program I want.
You'll notice I have a limit</code> variable used in the earlier two snippets for convenience, so I can quickly change the number of if statements.</p>
Let's start with a size of 2^8 if statements, just to make sure it's working.</p>
1</td> > python generator.py
</td></tr>
2</td> Calculating function size...
</td></tr>
3</td> Total time for calculating function size: 5.4430000091088004e-05s
</td></tr>
4</td> Writing file...
</td></tr>
5</td> Writing file... progress: 32/2980 bytes
</td></tr></tbody></table></code></pre>
When I run it using a quick index.js I whipped up with isOdd(1)</code>, I get a value of true</code>.  Exactly what I wanted, and the WASM parses correctly!
A quick test with 2^16 gives the same result, so I decide to go ahead and try a value of 2^32.
After an hour, it's still running.  Must be stuck writing the file, right?  Nope, it's stuck in the function_size</code> bit.</p>
I tried in vain to optimize it to the point where it won't take many hours to calculate the function size, but while testing, I stumbled across something unfortunate.
A limit of 2^24 causes the WASM compiler within Firefox to give up.  Turns out, WASM has a hard limit on the size of a function body.
There was no need to finish optimizing so that I could have my 2^32 WASM file, my dreams have been dashed.
I did some playing to reach the exact number, and the max limit I could reach via this strategy was 590063</code>.</p>
Within the time I set aside for this project, I couldn't quite solve this.  The only idea I have to get around this hard limit is to start dividing into multiple functions.
For that, though, you have to dynamically generate the functions as well, so I decided to let this one rest for now.  Perhaps I shall return someday, and a browser will load a WASM file containing all 4 billion if statements.</p>

Thoughts on Teaching Text Editing

Code Formatter, pt 2</h4>
A tool which closes a bracket for you, or maybe spaces out your brackets as you hit `Enter</code> instead of afterwards. This is something I went without for a while on my Neovim config, and it was incredibly painful.</p>`
`</p>`
`^{Credit XKCD for the image.</sup></p>}`

590 Thousand If Statements, For the Web

Brennen Puth

Using Hashcat (with a Nvidia GPU) on a bootc system

Symptom</h2>
`hashcat</code> installed via brew</code> cannot use the Nvidia GPU. On further inspection, even clinfo</code> cannot see the Nvidia GPU.</p>`

Step 1</h3>
Set up podman for Nvidia GPUs</a>.</p>

Step 3</h3>
Use `hashcat</code> as you normally would from your host system! distrobox</code> should take care of exporting the binary such that it's available to your terminal.</p>`
`Hopefully these steps helped. If they didn't work, shoot me an email</a> and I'll see what I can do to help!</p>`

Why so many notifications, Google?

Connecting to eduroam with NetworkManager on the CLI

Programmer Things That Aren't Building The Project

Local Digital Economy

The Fake Social Binary

bpOS: Why and how I made my own bootable container

Smart Window Resizing in Neovim

Brennen Puth

Using Hashcat (with a Nvidia GPU) on a bootc system

Symptom</h2> hashcat</code> installed via brew</code> cannot use the Nvidia GPU. On further inspection, even clinfo</code> cannot see the Nvidia GPU.</p>

Step 1</h3> Set up podman for Nvidia GPUs</a>.</p>

Step 3</h3> Use hashcat</code> as you normally would from your host system! distrobox</code> should take care of exporting the binary such that it's available to your terminal.</p> Hopefully these steps helped. If they didn't work, shoot me an email</a> and I'll see what I can do to help!</p>

Why so many notifications, Google?

Connecting to eduroam with NetworkManager on the CLI

Programmer Things That Aren't Building The Project

Local Digital Economy

The Fake Social Binary

bpOS: Why and how I made my own bootable container

Smart Window Resizing in Neovim

Thoughts on Teaching Text Editing

Code Formatter, pt 2</h4> A tool which closes a bracket for you, or maybe spaces out your brackets as you hit Enter</code> instead of afterwards. This is something I went without for a while on my Neovim config, and it was incredibly painful.</p> </p> Credit XKCD for the image.</sup></p>

590 Thousand If Statements, For the Web

Symptom</h2>
`hashcat</code> installed via brew</code> cannot use the Nvidia GPU. On further inspection, even clinfo</code> cannot see the Nvidia GPU.</p>`

Step 1</h3>
Set up podman for Nvidia GPUs</a>.</p>

Step 3</h3>
Use `hashcat</code> as you normally would from your host system! distrobox</code> should take care of exporting the binary such that it's available to your terminal.</p>`
`Hopefully these steps helped. If they didn't work, shoot me an email</a> and I'll see what I can do to help!</p>`

Code Formatter, pt 2</h4>
A tool which closes a bracket for you, or maybe spaces out your brackets as you hit `Enter</code> instead of afterwards. This is something I went without for a while on my Neovim config, and it was incredibly painful.</p>`
`</p>`
`^{Credit XKCD for the image.</sup></p>}`