Arvids Blog

Single file scripts using `uv`

Unknown — Fri, 27 Jun 2025 00:00:00 +0000

uv</a> is a package manager for Python that’s been gaining some traction for the past year or so.</p>

As already blogged/written</a> about</a> many</a> times</a>, uv</code> can be used to write single-file Python scripts without having to worry about virtual environments.</p>

However, they all suggest using #!/usr/bin/env -S</code> as a shebang to invoke the script with uv run --script</code> like this:</p>

#</span></span>!/usr/bin/env -S uv run --script</span>
</span></span></code></pre>
Unfortunately, this depends on a reasonably new version of /usr/bin/env</code>.  The -S</code> flag was introduced in version 8.30 (published 2018-07-01) of the GNU coreutils</a>.
For many of us on enterprise Linux distributions (e.g., RHEL 9, or Amazon Linux 2) this version is too new.</p>
But fear not, there are ways to achieve the same end results without having to update to an unsupported version of GNU coreutils.</p>
tl;dr: Use this instead:</strong></p>
#</span></span>!/bin/bash</span>
</span></span>"</span>"</span></span>"</span>exec"</span></span></span></span> uv run --</span>script</span> "</span>$</span>0</span></span>"</span></span> "</span>$</span>@</span></span>"</span></span></span>
</span>#</span></span> /// script</span>
</span></span>#</span></span> requires-python = ">=3.12"</span>
</span></span>#</span></span> dependencies = [</span>
</span></span>#</span></span>   "requests",</span>
</span></span>#</span></span> ]</span>
</span></span>#</span></span> ///</span>
</span></span>"</span>"</span></span>"</span>
</span></span></span></span></code></pre>
This is a Polyglot</a> script, a script or program that can be interpreted by more than a single language.
In this case, the script is valid Bash and Python. Let’s break it down how this works line by line:</p>
#!/bin/bash</code>: The standard shebang line for bash. The script is being interpreted by bash from here on.</p>
""</code>: An empty string. Strings that follow each other ("" ""</code>) are concatenated in bash.</p>
"exec" uv run --script "$0" "$@"</code>: This calls the exec</code> bash builtin</a> which replaces the entire program image with the
one that follows, in our case we invoke uv</code> with the arguments run --script "$0" "$@"</code>. The last two arguments mean we forward the path to the script ($0</code>)
and all arguments ($@</code>) to UV. The call to exec</code> ends the execution within bash; therefore, all lines that follow do not have to be valid bash anymore.</p>
Now our little script is not interpreted as bash anymore, but run as Python. We start from the top again:</p>
#!/bin/bash</code>: This is not a shebang anymore. To Python, this is just a comment.</p>
"""</code>: It’s not a string anymore, in Python, this is interpreted as a multiline comment; therefore, Python will skip over the entire remaining of the file.
The comments with /// script</code> are interpreted according to Pythons inline script metadata specifications</a>.</p>
And with this, we have a script that’s both valid bash and python which can be used instead of relying on new versions of /usr/bin/env</code>.</p>



Gerrit: Detached HEAD Workflow
Unknown — Sun, 20 Nov 2022 00:00:00 +0000
Gerrit</a> is a code hosting system similar to GitLab</a> or GitHub</a>, focusing on a better review experience rather than integrating with every other service on the planet and neglecting the core experience of their product.</p>
Since GitLab, GitHub, and their predecessors have been so prevalent in the broader software development community, Gerrit requires a bit of rethinking of interacting with your distributed version control system. Behind the scenes, Gerrit is still using Git, but unlike many other systems, it’s not using a branch-based workflow for submitting changes to the mainline1</a></sup>.</p>
This blog post aims to introduce an alternative working mode with Git and Gerrit called “Detached HEAD”. But before diving into that, let’s provide some background.</p>
In Git, the HEAD</code> is a pointer that points to the currently checked-out commit or branch. It’s Git’s way of knowing which commit you’re looking at in your local working tree. HEAD is a file that points to the commit.</p>
$</span></span> cat .git/HEAD</span>
</span>ref:</span></span> refs/heads/master</span>
</span>$</span></span> cat .git/refs/heads/master</span>
</span>3148fa73f6664f75746477188c7951a495252821</span></span>
</span></code></pre>
In the example, HEAD</code> is pointing at the ref/heads</code> of master</code>. The ref/heads/master</code> file points to the latest commit on master</code>.</p>
The HEAD</code> can be in multiple states: attached and detached. Typically, you’re working with an attached HEAD</code>. That means your HEAD</code> points to a branch (for example, master</code>). Whenever you’re committing work, the commit is recorded on the current branch HEAD</code> is currently referencing.
A detached HEAD</code> is whenever you haven’t checked out any branch, and all commits you’re making in this state are getting “lost” once you’re checking out a branch (don’t worry, you can recover them).</p>
Many publications erroneously frame the “detached HEAD” state as an error state that one must recover from, highlighting the lack of education about Git as a tool and how to use it effectively.</p>
With that out of the way, let’s get started. First, we’re preparing our working tree:</p>
$</span></span> git checkout master #</span></span> our work is based on the master branch</span>
</span></span></span>$</span></span> git checkout --</span>detach #</span></span> we're now in a detached `HEAD` state</span>
</span></span></span></span></code></pre>
We’re now in a detached HEAD</code> state. So you can work as you usually would by creating commits using git commit</code> or git commit --amend</code>.</p>

Note:</strong> In Gerrit, every commit is a change. If you’re pushing multiple commits, Gerrit will create the changes in a chain of dependencies. You can update a change by amending the commit and pushing it. Gerrit will create a new revision automatically.</p>
</blockquote>
$ #</span></span> Do some work, and create a README.md</span>
</span></span></span></span>$</span></span> git add README.md</span>
</span>$</span></span> git commit -</span>a</span></span>
</span></code></pre>
Once you’re ready to push your changes, you need to rebase your work on the master branch and push it.</p>
$</span></span> git checkout master</span>
</span>$</span></span> git pull --</span>rebase</span> </span>
</span>$</span></span> git checkout -</span>
</span>$</span></span> git rebase master</span>
</span></code></pre>
When you were checking out the master branch from your detached HEAD state, you got a scary message that you’re leaving behind commits that are not connected to any branch. That’s the state I mentioned earlier. You can ignore the warning in this context since we are switching back to the commit with git checkout -</code> (similar to how cd -</code> works).</p>
Your change is now rebased and ready to be pushed for code review to Gerrit.</p>
$</span></span> git push origin HEAD:refs/for/master</span>
</span></code></pre>
Gerrit has created a new change for every commit not on the master branch.</p>
You can now continue working in this detached HEAD state and add further commits or update existing commits.</p>
$</span></span> git add -</span>A</span></span>
</span>$</span></span> git commit -</span>a</span></span>
</span>$</span></span> git push origin HEAD:refs/for/master</span>
</span></code></pre>
Gerrit will now create a new change that depends on the change pushed earlier. That’s how you can create dependency chains between submitted changes, allowing you to keep each change as small as necessary.</p>
Congratulations, you should now be ready to start working with Gerrit.</strong></p>
For a more in-depth introduction to Gerrit, I recommend reading the Gerrit User Guide</a>.</p>
Cheatsheet</h2>
Starting a new change</h3>
This assumes that you pushed your last change to Gerrit. If you didn’t, save your change first (see here).</p>
$</span></span> git checkout master</span>
</span>$</span></span> git pull --</span>rebase</span> </span>
</span>$</span></span> git checkout --</span>detach</span></span>
</span></code></pre>
You can now commit as usual.</p>
Saving a change</h3>
You can save your current working state by creating a new named branch.</p>
$</span></span> git checkout -</span>b</span> your-branch-name</span>
</span></code></pre>
Now you can start working on a new change.</p>
Pushing a change</h3>
To push a change to Gerrit, you need to push to refs/for/<branch></code>. It would be best if you also rebased your change on the target branch before pushing, see here.</p>
$</span></span> git push origin HEAD:refs/for/master</span>
</span>Rebasing</span></span> a change on master</span>
</span>$</span></span> git checkout master</span>
</span>$</span></span> git pull --</span>rebase</span> </span>
</span>$</span></span> git checkout -</span>
</span>$</span></span> git rebase master</span>
</span></code></pre>
Fetching a change</h3>
To fetch a change:</p>

Navigate to the change on Gerrit.</li>
Click the “Download” button on the top right of the list of files in the patchset to open the “Download” overlay.</li>
Copy the “Checkout” line and execute it in your terminal.</li>
</ol>
It’ll put you into a detached HEAD state, and you don’t have to do anything else. You can start working like you usually would.</p>
Rebasing a change on top of a patchset</h3>
Like fetching a change from Gerrit, copy the “Checkout” line and remove the last && git checkout FETCH_HEAD</code>.</p>
$</span></span> git fetch ssh://username@host:29418/myProject refs/changes/74/67374/2</span>
</span>$</span></span> git rebase -</span>i</span> FETCH_HEAD</span>
</span></code></pre>
Updating a change</h3>
Again, like fetching a change from Gerrit, copy the “Checkout” line.</p>
$</span></span> git fetch ssh://username@host:29418/myProject refs/changes/74/67374/2</span> &&</span> git</span></span> checkout FETCH_HEAD</span>
</span>$ #</span></span> fix/update whatever you need</span>
</span></span></span></span>$</span></span> git add -</span>A</span></span>
</span>$</span></span> git commit --</span>amend #</span></span> Make sure to only amend, don't create new commits</span>
</span></span></span></span>$</span></span> git push origin HEAD:refs/for/master</span>
</span>$</span></span> git checkout - #</span></span> switch back to your old change</span>
</span></span></span></code></pre>
^{1</sup>
If you’ve used Perforce</a> in the past, you might be much more familiar with a branchless workflow.</p>
</div>}


Programming Fonts in 2021
Unknown — Tue, 30 Nov 2021 00:00:00 +0000
While browsing reddit I’ve came across “JetBrains Mono</em>”, the “new” programming font from JetBrains.</p>
This started, yet another, rabbit hole down the currently available programming fonts.</p>
The current contenders are:</p>


Minimal Makefile, Maximum Outcome - C++ Edition
Unknown — Mon, 11 Mar 2019 00:00:00 +0000
This is an amendment to one of my previous posts  which was building a small Makefile</code> for simple C projects.</p>
Here, I’m presenting essentially the same file, but with added C++ support:</p>


Top 5 Brand Names That Became Generic Terms
Unknown — Wed, 21 Nov 2018 00:00:00 +0000
Many terms we use everyday were once brand names, but since have become generic terms we’re now using to refer to the category of products in general. A majority of these are or were registered trademarks. These are known as genericized trademarks</a>.</p>


Better C++ Pseudo Random Number Generator
Unknown — Mon, 02 Jul 2018 00:00:00 +0000
Yesterday</a> I wrote about the terrible quality of the default pseudo random number generators in the C++ standard library. The article came to the conclusion they’re all around terrible, and should generally be avoided, yet, it didn’t provide any alternatives. Therefore, today I’ll provide you with three very good alternatives to the existing generators in the C++ standard library.</p>

splitmix</code></li>
xorshift</code></li>
pcg</code></li>
</ul>


On C++ Random Number Generator Quality
Unknown — Sat, 30 Jun 2018 00:00:00 +0000
tl;dr:</strong> Do not use <random></code>’s generators. There are plenty good alternatives, like PCG</a>, SplitMix, truncated Xorshift32*, or Xorshift1024*.</p>
A recent tweet reminded me of the <random></code> facilities in the C++ standard library. Having just recently studied and implemented a couple random number generators myself, I was curious how they hold up in a modern test.

From the get-go, I knew this is going to end badly, but I gave it a shot anyway.

I build a little test program, to feed into PractRand</a>:</p>


Intel & AMD Micro-Architecture Extended Instruction Sets
Unknown — Sun, 27 May 2018 00:00:00 +0000
The following is a list of architectures where certain instruction sets have been introduced first. The column “instr. set” only lists the introduced</em>, not all instruction sets.</p>


PDBs on Linux
Unknown — Sat, 05 May 2018 00:00:00 +0000
On Windows, debugger symbols aren’t stored side-by-side with the executable data in the same file. They’re stored in a .pdb</code> file (short for “program database”). This is especially great if you distribute your program to end-users, but still want to be able to debug any crashes. Just keep the .pdb</code> file somewhere save, and any crash log you get send can easily translated back into source locations.</p>
On Linux, debug symbols are traditionally stored inside the executable, and stripped (using strip(1)</code>) before distributing. This takes away the possibility to debug any crash, send to you from the stripped executable.</p>
Today I discovered a neat little trick to create something resembling PDBs on Linux, by making use of objcopy(1)</code>. In our example, I already have compiled an executable a.out</code>, which I want to distribute to my users:</p>


Memory Mapping on Windows (including Benchmark)
Unknown — Mon, 02 Apr 2018 00:00:00 +0000
The following tweet sparked my interest to investigate further into the different ways of mapping and unmapping memory on Windows, and trying to find the “best” way:</p>


Announcing the C++ Tour
Unknown — Fri, 08 Dec 2017 00:00:00 +0000
</p>
I’m proud to officially announce the C++ Tour.</p>


Using clang on Windows
Unknown — Thu, 03 Aug 2017 00:00:00 +0000
Update 1:</strong> Visual Studio 2017 works. Thanks to STL.</a></p>

Disclaimer:</strong> This isn’t about clang/C2, clang/C2 is Microsoft own fork of clang to work with their backend. This is using clang + llvm.</p>
tl;dr:</strong> All the source is in this repository: https://github.com/Leandros/ClangOnWindows</a></p>


Is my output going to bash.exe or cmd.exe?
Unknown — Sun, 23 Apr 2017 00:00:00 +0000
If you want to color the output of your terminal program in Windows, you might’ve noticed, that running it from different shells reacts differently.</p>
cmd.exe</code> does not recognize the ANSI escape sequences to change the foreground/background color, while bash.exe</code> does not recognize Windows’ SetConsoleTextAttribute</code></a>. This poses a problem. A way to detect if the output is going to bash.exe</code> or cmd.exe</code> is required.</p>


Stop using #ifdef for configuration
Unknown — Sat, 22 Apr 2017 00:00:00 +0000
Using #ifdef</code>’s to configure different conditional compilations is very error prone.</p>
I believe we’ve all had the case where something was compiled, while it shouldn’t have been, due to accidentally creating/including a #define</code> of the same name or defining it to 0 while checking with #ifdef</code>.</p>
While I won’t give you a solution to fix the flawed model of using the preprocessor for conditional inclusion, I’ll give you a solution to make it less error prone:</p>


C Wishlist: Inline Functions
Unknown — Sat, 11 Feb 2017 00:00:00 +0000
This is the first piece of a series of posts describing a few, very easily solvable, shortcomings of the C language. And proposing a way to fix these.

This is purely done the fact that I’m currently working on a C compiler. While I’ve written a few compilers over the years, none was actually intended to be used in production. This time it’s different!</p>


SIMD Instruction Format
Unknown — Fri, 09 Dec 2016 00:00:00 +0000
Did you know, that Intel has a naming scheme for their SIMD instructions? Neither did I.</p>
I found, by watching a CppCon talk by Tim Haines</a>, that

SIMD instruction have a pre-defined scheme which can be used to easily decode the, sometimes, cryptic mnemonics.

To much of my surprise, it’s not mentioned nor explained in any of Intel’s manuals.</p>


Test if a variable is unavailable in GDB
Unknown — Sun, 21 Aug 2016 00:00:00 +0000
GDB on macOS can’t display a few of the segment registers, which results in that the respective variables are not available for use. Trying to use them will only print $var is not available</code> and skip the rest of any currently running function.</p>
Merely executing this line</p>
printf</span></span> "</span></span></span> %04X</span> "</span></span></span>, $ds</span></span>
</span></code></pre>
without $ds</code> being available would stop executing the whole function.</p>
To lazy to read and just want the solution? Skip to the bottom.</em></p>


Minimal Makefile, Maximum Outcome
Unknown — Mon, 04 Apr 2016 00:00:00 +0000
Makefiles are flexible in many ways, it’s a small language in itself.

As I said in a post before</a>, I normally write the same Makefile</code> over and over, even just for compiling a simple project with two or more files. The there proposed Makefile</code>, however, grew quite big during the writing of the post.</p>
Today I want to present you a variant which is tiny, yet compiles your small to medium projects just fine, while still having dependency tracking and incremental compilation. To do this, I’ll make use of some of make</code>s very convenient implicit rules</a>.</p>


std::sort in C
Unknown — Sun, 03 Apr 2016 00:00:00 +0000
As some of you might already know through my Twitter, I’m currently attempting to build an advanced standard library for C, with similar performance and usage characteristics as C++’s STL.

It’s going really well so far, but the sort algorithm of std::sort</code> is giving me headaches.</p>


Generic Makefile
Unknown — Sat, 19 Mar 2016 00:00:00 +0000
Update:</strong> Now also supports C++, see the Github repository</a>) for the updated file.</p>
In every single project, or even just test, I write the same simple Makefile</code> over and over, by now I can write it without looking up anything. And if I forgot something, I would go through my old projects, to dig up the definition I need.

Today I got fed up with that, and decided to write one completely generic Makefile</code> I can just reuse in all my projects. It only requires a reasonably new make, nothing else.</p>


Debug Messages in no$gmb and BGB
Unknown — Sat, 12 Mar 2016 00:00:00 +0000
I’ve recently started working on a little side project, involving Gameboy development. While reading through the docs of BGB, I noticed it supports printing debug messages to a debug console, I, however, couldn’t get it working, since it was using the syntax of the no$gmb assembler. Thanks to the people of #gbdev on EFnet, especially beware</em>, I’ve eventually got it working, and made an rgbds macro out of it.</p>
Without further ado, here is a gist of the it:</p>


Fixing Slow Vim in Tmux and iTerm2
Unknown — Tue, 26 Jan 2016 00:00:00 +0000
I’ve noticed my Vim got horribly slow once I had multiple panes in tmux open.

My initial investigation led to the fact, that tmux is slowing Vim down, and a quick Google search confirmed that.</p>
After removing all plugins in Vim/tmux, I dug through the iTerm2 settings and found this:</p>


SysInfo - Beautiful System Diagnosis
Unknown — Tue, 26 Jan 2016 00:00:00 +0000
</p>
I’ve recently been reminded of a tool called Archey, it’s used to display system specs in a delightful manner. You often see it in screenshots of some other people desktops of the Arch Linux community.</p>
I missed such a tool on OS X, and that’s why I wrote SysInfo. It’s available on Github.</p>


About Me
Unknown — Fri, 01 Jan 2016 00:00:00 +0000

Arvid Gerstmann is an entrepreneur, software engineer, manager, and occasional speaker</a>. He is the founder of RagnarLab</a>, a digital consulting firm specialized in the Rust programming language</a>. Arvid has previous experience as Head of Software Engineering at ZEISS Vision</a>, Head of Software and Architecture at Doxy.me, Inc.</a>, and served as the Chief Technology Officer at Appico.</p>
Holding a degree in electrical engineering, Arvid is a self-taught programmer. He is interested in writing video games, compilers, and other low-level systems and is most fluent in Rust, C, and C++. However, he has professional experience in various technologies (incl. JS, TypeScript, Node.js, AWS, and Azure). Arvid loves solving complex problems and mentoring other engineers.</p>
Arvid loves good espresso and is an avid reader. He usually travels nature with his Mercedes-Benz Marco Polo camper van, preparing for the upcoming hike or climbing the next big mountain with his girlfriend and his adorable Spanish water dog, Charlie. He currently lives in Germany.</p>
Arvid is available for contracting. Visit ragnarlab.com</a> to learn more.</p>
You can find him on BlueSky</a>, LinkedIn</a> or Github</a>.</p>


Talks
Unknown — Fri, 01 Jan 2016 00:00:00 +0000
This page lists all my recent talks and links to the slides and recording:</p>
Table of Contents</h2>

emBO++ 2019</a></li>
C++ On Sea 2019</a></li>
Meeting C++ 2018</a></li>
CppCon 2018</a></li>
Meeting C++ 2017</a></li>
</ul>
emBO++ 2019</h2>
Refactor C++ Using LibTooling</h3>

Slides</a></li>
Video</a></li>
</ul>
C++ On Sea 2019</h2>
Building a C++ Reflection System in One Weekend Using Clang and LLVM</h3>

Slides</a></li>
Code</a></li>
Video</a></li>
</ul>
Meeting C++ 2018</h2>
Building a C++ Reflection System in One Weekend Using Clang and LLVM</h3>

Slides</a></li>
Code</a></li>
Video</a></li>
</ul>
CppCon 2018</h2>
Building a C++ Reflection System in One Weekend Using Clang and LLVM</h3>

Slides</a></li>
Code</a></li>
Video</a></li>
</ul>
Meeting C++ 2017</h2>
A Very Quick View Into a Compiler (Lightning Talk)</h3>

Slides</a></li>
Notes</a></li>
Video</a></li>
</ul>
FASTBuild: A Short Introduction  (Lightning Talk)</h3>

Slides</a></li>
Notes</a></li>
Github</a></li>
Video</a></li>
</ul>
The Case for Vendored Builds (Lightning Talk)</h3>

Slides</a></li>
Notes</a></li>
Video</a></li>
</ul>


Resurrected
Unknown — Sat, 30 May 2015 00:00:00 +0000
I’ve resurrected my blog, and put my .io domain to a good use, and set-up a ghost blog.

So far, I’ve always had my personal websites cluttered on many domains, but this came to an end, everything is now on arvid.io.</p>
You can expect new posts in the next few weeks, I already have something prepared.</p>


Automatically exporting assets from Sketch into Android Studio
Unknown — Sat, 03 May 2014 00:00:00 +0000
Matt Zanchelli wrote a blog post</a> about automatically exporting assets from Sketch into Xcode, unfortunately this method can only be used with Xcode projects, but fortunately we have Gradle.</p>


[Android 4] ActionBar with Tabs example
Unknown — Sat, 18 Feb 2012 00:00:00 +0000
Example Application & Code for ActionBar with Tabs Layout optimized for Android 4.0.

I’am slowly optimizing my apps for Android 4.0 and because there aren’t much Example / Resources I thought I publish my own code as example. It is a simple Layout. Code and anything else after break</p>

Arvids Blog

Single file scripts using `uv`

Gerrit: Detached HEAD Workflow

Cheatsheet</h2> Starting a new change</h3> This assumes that you pushed your last change to Gerrit. If you didn’t, save your change first (see here).</p>

Starting a new change</h3> This assumes that you pushed your last change to Gerrit. If you didn’t, save your change first (see here).</p>

Saving a change</h3> You can save your current working state by creating a new named branch.</p>

Pushing a change</h3> To push a change to Gerrit, you need to push to refs/for/<branch></code>. It would be best if you also rebased your change on the target branch before pushing, see here.</p>

Fetching a change</h3> To fetch a change:</p>

Programming Fonts in 2021

Minimal Makefile, Maximum Outcome - C++ Edition

Top 5 Brand Names That Became Generic Terms

Better C++ Pseudo Random Number Generator

On C++ Random Number Generator Quality

Intel & AMD Micro-Architecture Extended Instruction Sets

PDBs on Linux

Memory Mapping on Windows (including Benchmark)

Announcing the C++ Tour

Using clang on Windows

Is my output going to bash.exe or cmd.exe?

Stop using #ifdef for configuration

C Wishlist: Inline Functions

SIMD Instruction Format

Test if a variable is unavailable in GDB

Minimal Makefile, Maximum Outcome

std::sort in C

Generic Makefile

Debug Messages in no$gmb and BGB

Fixing Slow Vim in Tmux and iTerm2

SysInfo - Beautiful System Diagnosis

About Me

Talks

emBO++ 2019</h2>

C++ On Sea 2019</h2>

Meeting C++ 2018</h2>

CppCon 2018</h2>

Meeting C++ 2017</h2>

Resurrected

Automatically exporting assets from Sketch into Android Studio

[Android 4] ActionBar with Tabs example