larsch

Dancing Polygons

Wed, 05 Jan 2022 05:41:00 +0000

From the department of recreational coding comes another little math toy inspired by Mathologer’s 3-4-7 Miracle video. My little Dancing Polygons toy lets you play around with various choices of regular polygons moving in a patterns with some surprising regularity.

This 1301 byte PDF file has 2 million pages

Mon, 12 Apr 2021 17:44:00 +0000

This innocent looking 1301 byte .PDF file actually has 2 million pages. The file only has 10 objects, of which 7 are page groups that recursively contain 8 copies of the next page group for a total of 8^7 = 2097152 copies of the same single page.

Firefox and Edge appears to get stuck allocating gigabytes of memory and will eventally crash. Impressively, SumatraPDF actually handles the file very well.

Adobe Acrobat Reader does not render the PDF file, as it does not seem to support having the same Page object used more than once. Checking the specification did not immediately yield a clear answer to whether page reuse is legal. The entire structure is made of indirect object references, and I did not find any indication that an object can’t be reused more than once.

Splitting Git Commits

Wed, 20 Dec 2017 12:00:00 +0000

Change your commit history is not something to do under normal development, but it can be an extremely valuable tool while doing change set management. It helps keeps a commit history (a change set list) clean and managable. A clean history enables easy cherry-picking of commits if you are maintaining multiple branches or versions.

Here’s an example of how to split a mega-commit into multiple smaller commits. The tools we are going to use are

git rebase (changing history)
git reset (for undoing commits)
git stash (for managing unwanted changes)

The general approach we are going to follow is:

Rebase to edit the history
Rollback mega-commit
Repeatedly apply smaller commits while testing each commit.

Before starting I always ensure that the working directory is clean, with no uncommit changes and no untracked files.

The first step is to initiate the rebase. Rebase can be used to move a branch up on a new baseline (upstream), but you can also use it to edit the history while keeping the baseline the same. We will use the --interactive option to specify that we want to change things around. The upstream version in this case will be the newest commit we want to leave unchanged and keep as the base version for our new history. Find the commit id of this commit in the history and start the rebase:

git rebase --interactive <upstream>

Now we will change the rebase operation of one (or more) commits. To split a commit we will need to change the operation of those commits to ‘edit’.

When the rebase operation reaches the commit we want to edit, it will drop into the command prompt. It has already applied the commit, so to change it we will first undo it:

git reset HEAD~

This will remove the commit, move HEAD back to the previous commit (HEAD~) while leaving all the changes of the commit in the working directory.

Now we can be commiting the individual changes we want. I use git add to add indivial files and git add --patch to selectively add invidual changes. If a change is completely interleaved, the patch can be edited directly while doing git add --patch.

Before we commit the partial change, we might want to check if it can be built and verify that the unit tests pass. Currently we still have all the changes in the working directory, so lets get rid of those using git stash:

git stash --keep-index --include-untracked

Now all our changes (except those we added to the index using git add) are in the stash and have been removed from the working directory. --keep-index ensures that all the changes we added are not also stashed (stash’s default behaviour). --include-untracked push all untracked files into the stash as well.

After building and testing, we can commit our change. If there were any problems, we can apply our stashed changes (git stash apply) and repeated our selective addition of changes to the index.

git commit

Followed by reapplying our changes remaining in the stash:

git stash apply

At this point we are back with a set of changes in the working directory, but with a new commit in the history containing some of the changes. We can either commit the rest in one go, or repeat partial commits using this procedure.

When everything has been commited, we can continue the rebase:

git rebase --continue

As a final sanity check, we can compare our resulting state of the tree with what we had before the rebase. For this we need the commit ID of the HEAD commit before we started the rebase (find using git reflog).

git diff <commit id>

If you correctly applied all the changes and didn’t discard any changes, this output should be completely empty.

Arduino Pomodoro Timer

Thu, 30 Mar 2017 21:40:00 +0000

I have been thinking about making a Pomodoro timer for quite a while. I thought of combining a tactile button-based timer with a clear indicator light to make my colleagues aware or my work mode, hopefully reducing interruptions during focus and flow.

This is what I’ve come up with:

This a 3d-printed/Arduino 25-minute + 5-minute Pomodoro timer, showing a red indicator light while running. Then the Pomodoro is up, the light turns green and sets a 5 second timer:

This is actually version 2. My first Pomodoro timer project ended up being fun but not that useful.

The indicator light is also the button! The indicator is printed with 2 shells for a total 0.8 mm thickness in white filament. The diode inside is a 8 mm diffuse APA106 RGB diode with integrated IC (WS2812b compatible). I chose this because I had some lying around and it is quite bright. An PWM-driven RGB diode would also work.

The inside is a spiderweb. It was an easy way to make it compact and get the enclosure I wanted.

The 7-segment display is a 12-pin common anode type and takes up 12 pins on the Arduino.

Design and implementation choices:

The 25-minute focus period and 5-minute break period are fixed (Pomodoro standard)
The 25-minute focus period can be interrupted by holding the button. The timer will return to idle mode.
The 5-minute pause timer can’t be interrupted. This is to prevent myself from just restarting another Pomodoro focus period.

Ideas for version 3:

Integrate with a PC-application that set all applications to Do Not Disturb.
Completed Pomodoro counter or score.
The indicator/button could be more robust

The source, STL and FreeCAD files for this project are available on GitHub.

Solid of constant width in OpenSCAD

Thu, 18 Feb 2016 20:10:05 +0000

Here’s a basic OpenSCAD script generating a model of a solid of constant width based on a tetrahedron. Now to figure out how to position it with constant distance to the plane…

u = 10;
diameter = sqrt(8*u*u);
intersection() {
  translate([u,u,u]) sphere(diameter);
  translate([u,-u,-u]) sphere(diameter);
  translate([-u,u,-u]) sphere(diameter);
  translate([-u,-u,u]) sphere(diameter);
}

Or check out this Numberphile video: