brtmr

Lets Encrypt Beta

Sun, 29 Nov 2015 21:00:00 +0100

As of today, brtmr.de is part of the letsencrypt.org closed beta. If you inspect the certificate by clicking on the little lock-symbol in the adress bar of your browser, you should see something like this:

The process was mostly painless - I just cloned the github repo, as explained in the official documentation:

git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt

Afterwards, installation and configuration of the required packages can be run with the

./letsencrypt-auto

command.

One issue I was not previously not aware of is that the installation of the client is rather memory hungry. So if you are like me, and you are running your site on a tiny VPS, then you might run into a rather cryptic error message, like this. This problem can be fixed by creating a swapfile so that the installation process does not run out of memory, as pointed out in this github-issue.

After that, everything worked smoothly. I also enabled the rewrite option, so that apache rewrites every http connection into https.

My thanks to the people at letsencrypt for making this process easy and free, and providing an important step to hopefully making the web https-only.

Introducing Eden-Tracelab

Sat, 17 Oct 2015 22:00:00 +0200

In this post I want to introduce a program that I wrote in the course of my recently finished Bachelor thesis in Computer Science. It’s called Eden-Tracelab, and it is an application for analyzing trace files generated by programs written in the Eden programming language. The Eden language is a dialect of Haskell, specifically designed to implement parallel programs. If you want to learn more about Eden, check out the official website. Eden-Tracelab is a tool for inspecting and debugging the runtime behavior of such programs. It is designed to be used in addition to the already existing tool EdenTV.

How it works

The program consists of three main parts: The first part is a command-line tool to analyze trace files, and to store the generated information into a postgres database. The second part is a web service to serve the event information over a JSON API. The final part is a web application which visualizes the trace analysis, and which provides the user with multiple dynamic views on the data. The following screenshot shows an overview of the web application:

When opening the web interface, Eden-Tracelab will allow the user to chose from a list of analyzed traces.
The user can chose between three views: machines, processes and threads
Initially, the application will start with a relatively low level of detail. This allows for a faster overview of the trace. The level of detail can be adjusted, to allow for a more thorough inspection of the trace.
The actual visualization: Shows a time line for each machine, process or thread (depending on the view). The time line is color-coded, where each color corresponds to a specific state (for example, red means blocked).

Implementation

The tool for analyzing trace files is written in Haskell, as is the web service to serve event data to the front end. The HTML5 viewer is written in CoffeeScript, and uses an HTML5 canvas to display event data.

At this point, the program is still very much a work in progress, but now that the thesis is finished, I can finally publish the source code along with the thesis itself. If anyone is interested in learning more, the full text of the thesis is available here.

The Code

The code for the project is available on github. The project is split into two repositories: One containing the command line tool and one containing the web service and HTML5 viewer.

Hexagonal Langton's Ant 2 - Colors, Gliders and Highways

Mon, 05 Oct 2015 22:00:00 +0200

The rectangular version of langtons ant has a very interesting property: The ant will, after some time, always build a highway, meaning it will embark on an endlessly repeating pattern that takes it farther and farther away from the origin. I was curious whether it was possible to build a highway with the ant walking on hexagons. The rules described in the post below seemed to generate a symmetric pattern around the origin, but not a highway going into a specific direction. The original ant also has a couple of variations involving multiple colors. The idea is that instead of switching between two colors, the ant would cycle a tile between a list of colors, each assigned with a specific direction the ant will take when entering the tile. The following graphic shows all the directions the ant can take when entering a hexagon, relative to its original direction (marked with a red arrow).

Each direction is assigned with a name. The names are left, right, forward, backward, starboard, port - abbreviated by their initials L,R,F,B,S,P. A specific set of rules can now be described with a series of these names. The simple version demonstrated below can be described with the series RL, meaning that the first time the ant enters a space, it will turn right, afterwards left. Now, if we add more colors to the sequence, we can construct longer sequences that describe different behaviors. You can try this in the following tool, by defining your own sequences, and then watch the emerging patterns. Simply type a sequence containing the six letters in any configuration into the input field, press the start-button, and watch the pattern emerge. Some sequences seem to only create chaotic growth, while others do indeed create highways of differing complexity. The gallery of sequences below shows screenshots of highways created by different rules. The code for this interactive version can also be found on my github profile.

FB

Super simple, and somewhat of a cheat. Creating a highway by rocking back and forth on each hexagon on a line.

RLBF

A little more interesting - moves around chaotically for a while, but then creates a highway with a sawtooth-like appearance.

SPS

My favorite pattern: Creates a triangular glider, that creates a dotted line along its path. Try it out to see it action.

SPSS

Similar to the previous one, but creates a continuous line along the glider’s path.

SSPSS

Similar to the previous one, but alternating colors on the highway.

PSS

Another highway being build by a glider.

SPSSS

The most complex highway I have found so far. Looks like a sequence of stacked pyramids.

PSSP

Creates a highway looking like a chain.

SPSSB

Creates a star-like structure around the origin, then creates a glider that rocks back and forth an creates a series of parallel pairs of hexagons.

LPRL

Creates a highway looking like a chain.

PBS, PBBS, PBBBS, PB….BS

Creates a four tile glider. Movement speed depends on the number of Bs provided.

LSL

Slowly creates a labyrinth, while constantly shifting its walls.

PBPSPS

Creates a zigzag shaped highway.

LFPSPS

Moves chaotically for a while, then creates a broad highway.

PBPS

A glider on a highway that builds its own ‘launcher’.

PRL

A two lane highway.

RRP

The red hexagons seem to always form closed loops, one of which contains (almost) all the blue hexagons.

All these patterns where found within in a short time through trial-and-error, simply through trying short, random combinations. I have only covered a very small part of the 4-letter search space. If you find an interesting pattern, let me know, I would like to collect a more complete list! mail [at] brtmr [dot] de

Hexadecimal Langtons Ant

Thu, 01 Oct 2015 22:00:00 +0200

Langtons ant is a popular cellular automaton. It is interesting to me because I am often fascinated by the way that complex patterns can form from a set of very simple rules. You can read about it on Wikipedia. or watch the Numberphile video. After watching the Numberphile video I got interested in the possible patterns that might emerge when Langtons Ant is not walking atop a plane made of squares, but out of hexagons.

The rules for this version are identical to the original version. When the ant lands on a new tile, it does the following:

Turn left or right, depending on whether the tile is black or white
Flip the color of the tile
Move one tile forward

I did not do any deep analysis on this, other than staring on the animation, but the pattern that emerges seems to be very symmetrical along a diagonal axis.