kilko.de - original posts

Importing CSV data into SQLite

2026-07-01T00:00:00+00:00

Creating a table from CSV data is very straightforward.</p>

sqlite3</span> file.sqlite</span></span>
sqlite</span>></span> .mode</span> csv</span></span>
sqlite</span>></span> .import</span> data.csv</span> tablename</span></span>
sqlite</span>></span> .exit</span></span></code></pre>
That's it.</p>



Youtube RSS Feeds
2026-03-23T00:00:00+00:00
Any channel can be subscribed to via RSS by using the following URL format:</p>
https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID</span></span></code></pre>
The easiest way to get this is to just let your RSS Reader subscribe to the channel's main URL, it will usually figure out the feed location.</p>
The default feed includes all</em> videos however, this includes live videos and shorts, there's a few different playlist feeds that can be used to filter these out, instead of using the channel_id</code> parameter, use the playlist_id</code> parameter like so:</p>
https://www.youtube.com/feeds/videos.xml?playlist_id=PLAYLIST_ID</span></span></code></pre>
The playlist ID is the same as the channel ID (which includes the UC</code> prefix), but with a different prefix:</p>

All videos: UU</code> + rest of channel ID</li>
Standard videos: UULF</code> + rest of channel ID</li>
Shorts: UUSH</code> + rest of channel ID</li>
Livestreams: UULV</code> + rest of channel ID</li>
</ul>
For example, the feed URL for stuffmadehere's channel would be transformed like this to get only standard videos:</p>
https://www.youtube.com/feeds/videos.xml?channel_id=UCj1VqrHhDte54oLgPG4xpuQ</span></span>
-></span></span>
https://www.youtube.com/feeds/videos.xml?playlist_id=UULFj1VqrHhDte54oLgPG4xpuQ</span></span></code></pre>
Kudos to github.com/FreshRSS/Extensions/issues/234#issuecomment-2738509387</a></p>


GPTDash
2025-12-29T00:00:00+00:00
Benny</a> and I have been playing our "reverse turing test" game — aka GPTDash — at Datenspuren</a> for two years now, so we decided it's time we took it to the big stage. We wanted to play it with like a hundred people, but didn't expect to get the big stage™ at 39c3, hall 1 that seats like 3k people. At the prime time gameshow slot late on day 2. That was quite humbling, especially since the app wasn't even close to ready at the time.</p>
We had the foresight to test the hell out of the app, but were still met with a few stupid issues on-stage. We've been told it wasn't half as bad watching it live, but oh wow did we have a hard time keeping everything running. The app was built to easily handle 3k concurrent websocket connections, the server was almost idling during the event, but at some point it still just decided to drop and no longer allow WS connections. HTTP worked fine. No clue what happened there, it felt</em> like the network was just not allowing any WS packets to go through. I realize that makes no sense. I'd love to figure out what happened there some day.</p>
</iframe>
In hindsight it definitely was fun though. We saw around 2.5k people participating live at some point — it was open to the live stream viewers as well. I can't remember there being a gameshow at Congress that's directly interactive for the audience with a large crowd, maybe it was a first in that regard!</p>


Rotate videos
2025-08-20T00:00:00+00:00
Rotate videos using ffmpeg by transposing them. The command to do so is:</p>
$</span> ffmpeg</span> -</span>i</span> input.mp4</span> -</span>vf</span> "</span>transpose=1</span>"</span> output.mp4</span></span></code></pre>
The possible rotations are the following.</p>
0 = 90CounterCLockwise and Vertical Flip (default)</span></span>
1 = 90Clockwise</span></span>
2 = 90CounterClockwise</span></span>
3 = 90Clockwise and Vertical Flip</span></span></code></pre>
Use -vf "transpose=2,transpose=2"</code> for 180 degrees.</p>
Credits go to stackoverflow.com/a/9570992/1843020</a></p>


Keep subtitles while transcoding
2025-08-20T00:00:00+00:00
To keep all existent subtitle tracks when transcoding media with ffmpeg, just pass the flag -map 0:s -c copy</code>, e.g.</p>
$</span> ffmpeg</span> -</span>i</span> /path/to/media.{mkv,mp4}</span> -</span>map</span> 0:s</span> -</span>c</span> copy</span></span></code></pre>


Create video from image and audio
2025-08-20T00:00:00+00:00
Technically something simple along the following lines would work.</p>
ffmpeg</span> -</span>i</span> image.png</span> -</span>i</span> audio.mp3</span> video.mp4</span></span></code></pre>
This does however create a file with just a single frame, which doesn't really work on YouTube for example. The following creates a video with repeating frames.</p>
ffmpeg</span> -</span>r</span> 1</span> -</span>loop</span> 1</span> -</span>i</span> image</span>.</span>png</span> -</span>i</span> audio</span>.</span>mp3</span> -</span>acodec</span> copy</span> -</span>shortest</span> -</span>vf</span> scale</span>=</span>1280</span>:</span>720</span> video</span>.</span>mp4</span></span></code></pre>
Credits go to superuser.com/a/1041820/236423</a></p>


Concatenate videos
2025-08-20T00:00:00+00:00
Concating several video files with ffmpeg is very straightforward if they all share the same container and codec.
Add all input files to a text file listing their relative or absolute paths.</p>
file</span> '</span>file1.mp4</span>'</span></span>
file</span> '</span>file2.mp4</span>'</span></span>
.</span>.</span>.</span></span></code></pre>
Run the following.</p>
$</span> ffmpeg</span> -</span>f</span> concat</span> -</span>safe</span> 0</span> -</span>i</span> input.txt</span> -</span>c</span> copy</span> output.mp4</span></span></code></pre>
-safe 0</code> can be omitted if the filepaths are relative.</p>


Change video container
2025-08-20T00:00:00+00:00
Quickly change a file's container using magic</em> shell syntax.</p>
ffmpeg</span> -</span>i</span> path/to/file.{webm,</span> mp4}</span></span></code></pre>


Decoding Unknown Data with Codable
2021-09-01T00:00:00+00:00
A friend recently asked me how to decode the following JSON through Swift's Codable</code> type.</p>
{</span></span>
  "</span>a</span>"</span>: </span>1</span>,</span></span>
  "</span>b</span>"</span>: </span>"</span>foobar</span>"</span>,</span></span>
  "</span>option.extra</span>"</span>:</span> {</span></span>
    "</span>a</span>"</span>:</span> 1</span></span>
  }</span>,</span></span>
  "</span>option.extra.more</span>"</span>: </span>4</span></span>
}</span></span></code></pre>
The problem is that only the first two keys (a</code> and b</code>) are guaranteed to exist, anything aside from that (here everything prefixed with option</code>) is extra and unknown at compile-time. Unknown keys should not be discarded however, they should be decoded into a dictionary for later use, we want a type like this.</p>
struct</span> Json</span> {</span></span>
  var</span> a:</span> Int</span></span>
  var</span> b:</span> String</span></span>
  var</span> extraOptions:</span> [</span>String</span>:</span> ?</span>]</span></span>
}</span></span></code></pre>
It's a bit unclear what type to use for extraOptions</code>, since we don't really know what the values are. They can be anything, as long as it's decodable. The folks at Flight School</a> have a fantastic package for us to facilitate that conveniently called AnyCodable</a>, which provides type-erased wrappers for Encodable</code>, Decodable</code>, and Codable</code> values. We can use that to represent the requirement of having anything</em>, as long as it's decodable, by defining the type as follows.</p>
struct</span> Json</span> {</span></span>
  var</span> a:</span> Int</span></span>
  var</span> b:</span> String</span></span>
  var</span> extraOptions:</span> [</span>String</span>:</span> AnyDecodable</span>]</span></span>
}</span></span></code></pre>
As it stands we're getting the automatically synthesized implementation of Json</code>'s initializer, which will try to find a dictionary called extraOptions</code> in the source JSON, which obviously isn't present. We'll have to implement the initializer ourselves. Doing so will also require us to define a type conforming to CodingKey</code>, which we can use to specify the encoded keys in our source data.</p>
extension</span> Json</span>:</span> Decodable</span> {</span></span>
  private</span> enum</span> CodingKeys</span>:</span> CodingKey</span> {</span></span>
    case</span> a</span>, </span>b</span></span>
  }</span></span>
</span>
  init</span>(</span>from</span> decoder</span>: </span>Decoder</span>)</span> throws</span> {</span></span>
    let</span> container </span>=</span> try</span> decoder.</span>container</span>(</span>keyedBy</span>:</span> CodingKeys.</span>self</span>)</span></span>
    self</span>.</span>a</span> =</span> try</span> container.</span>decode</span>(</span>Int</span>.</span>self</span>, </span>forKey</span>:</span> .</span>a</span>)</span></span>
    self</span>.</span>b</span> =</span> try</span> container.</span>decode</span>(</span>String</span>.</span>self</span>, </span>forKey</span>:</span> .</span>b</span>)</span></span>
    self</span>.</span>extraOptions</span> =</span> [</span>:</span>]</span></span>
  }</span></span>
}</span></span></code></pre>
We've now run into the problem of somehow having to specify all keys in our CodingKeys</code> enum, which obviously doesn't help for unknown keys. What we can do though is to use the CodingKey</code> protocol to create our own dynamic</em> key handling type, which can handle any String</code> as a key.</p>
struct</span> DynamicCodingKeys</span>:</span> CodingKey</span> {</span></span>
  var</span> stringValue:</span> String</span></span>
  init?</span>(</span>stringValue</span>: </span>String</span>)</span> {</span></span>
    self</span>.</span>stringValue</span> =</span> stringValue</span></span>
  }</span></span>
</span>
  //</span> not used here, but a protocol requirement</span></span>
  var</span> intValue:</span> Int</span>?</span></span>
  init?</span>(</span>intValue</span>: </span>Int</span>)</span> {</span></span>
    return</span> nil</span></span>
  }</span></span>
}</span></span></code></pre>
While we could use this entirely instead of our previous implementation, I personally find it quite a bit cleaner to keep the existing CodingKeys</code> for known keys, but cover everything else with the DynamicCodingKeys</code>. Creating a new container from our decoder keyed with DynamicCodingKeys</code> however will give us a container containing all</em> keys, not just the extra ones, so we'll have to filter out those we've already taken care of, leaving us with something like this.</p>
extension</span> Json</span>:</span> Decodable</span> {</span></span>
  private</span> enum</span> KnownCodingKeys</span>:</span> CodingKey</span>, </span>CaseIterable</span> {</span></span>
    case</span> a</span>, </span>b</span></span>
</span>
    static</span> func</span> doesNotContain</span>(</span>_</span> key</span>: </span>Json.DynamicCodingKeys</span>)</span> -></span> Bool</span> {</span></span>
      !</span>Self</span>.</span>allCases</span>.</span>map</span>(</span>\.</span>stringValue</span>)</span>.</span>contains</span>(</span>key.</span>stringValue</span>)</span></span>
    }</span></span>
  }</span></span>
</span>
  struct</span> DynamicCodingKeys</span>:</span> CodingKey</span> {</span></span>
    var</span> stringValue:</span> String</span></span>
    init?</span>(</span>stringValue</span>: </span>String</span>)</span> {</span></span>
      self</span>.</span>stringValue</span> =</span> stringValue</span></span>
    }</span></span>
</span>
    //</span> not used here, but a protocol requirement</span></span>
    var</span> intValue:</span> Int</span>?</span></span>
    init?</span>(</span>intValue</span>: </span>Int</span>)</span> {</span></span>
      return</span> nil</span></span>
    }</span></span>
  }</span></span>
</span>
  init</span>(</span>from</span> decoder</span>: </span>Decoder</span>)</span> throws</span> {</span></span>
    let</span> container </span>=</span> try</span> decoder.</span>container</span>(</span>keyedBy</span>:</span> KnownCodingKeys.</span>self</span>)</span></span>
    self</span>.</span>a</span> =</span> try</span> container.</span>decode</span>(</span>Int</span>.</span>self</span>, </span>forKey</span>:</span> .</span>a</span>)</span></span>
    self</span>.</span>b</span> =</span> try</span> container.</span>decode</span>(</span>String</span>.</span>self</span>, </span>forKey</span>:</span> .</span>b</span>)</span></span>
</span>
    self</span>.</span>extraOptions</span> =</span> [</span>:</span>]</span></span>
    let</span> extraContainer </span>=</span> try</span> decoder.</span>container</span>(</span>keyedBy</span>:</span> DynamicCodingKeys.</span>self</span>)</span></span>
</span>
    for</span> key </span>in</span> extraContainer.allKeys </span>where</span> KnownCodingKeys.</span>doesNotContain</span>(</span>key</span>)</span> {</span></span>
      let</span> decoded </span>=</span> try</span> extraContainer.</span>decode</span>(</span>AnyDecodable.</span>self</span>, </span>forKey</span>:</span> DynamicCodingKey</span>(</span>stringValue</span>:</span> key.</span>stringValue</span>)</span>!</span>)</span></span>
      self</span>.</span>extraOptions</span>[</span>key.</span>stringValue</span>]</span> =</span> decoded</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>
The static function KnownCodingKeys.doesNotContain(_:)</code> is totally not necessary, but it makes the loop in the initializer nicer to read.</p>
When trying to run this, we see that it works as intended!</p>
let</span> json </span>=</span> """</span></span>
{</span></span>
  "a": 1,</span></span>
  "b": "foobar",</span></span>
  "option.extra": {</span></span>
    "a": 1</span></span>
  },</span></span>
  "option.extra.more": 4</span></span>
}</span></span>
"""</span>.</span>data</span>(</span>using</span>:</span> .</span>utf8</span>)</span>!</span></span>
</span>
let</span> decoded </span>=</span> try</span> JSONDecoder</span>(</span>)</span>.</span>decode</span>(</span>Json.</span>self</span>, </span>from</span>:</span> json</span>)</span></span>
print</span>(</span>decoded</span>)</span></span></code></pre>Json</span>(</span></span>
  a</span>:</span> 1</span>,</span></span>
  b</span>:</span> "</span>foobar</span>"</span>,</span></span>
  extraOptions</span>:</span> [</span></span>
    "</span>option.extra</span>"</span>:</span> AnyDecodable</span>(</span>[</span>"</span>a</span>"</span>:</span> 1</span>]</span>)</span>,</span></span>
    "</span>option.extra.more</span>"</span>:</span> AnyDecodable</span>(</span>4</span>)</span></span>
  ]</span></span>
)</span></span></code></pre>
That's it, cya for the next blog post in - check's watch</em> - three years 😅</p>


Simulating a scan
2018-09-01T00:00:00+00:00
Fake a printed, hand-signed and scanned document using imagemagick. Beat the bureucracy.</p>
$</span> convert</span> input.pdf</span> -</span>colorspace</span> gray</span> \(</span> +clone</span> -</span>blur</span> 0x0.1</span> \)</span> +swap</span> -</span>compose</span> divide</span> -</span>composite</span> -</span>linear-stretch</span> 5%x0%</span> -</span>rotate</span> 0.5</span> scan.pdf</span></span></code></pre>
Documentation on using -blur</code> can be found here</a>.</p>
Credits go to tex.stackexchange.com/a/94541</a></p>


Server Setup with traefik and docker-compose
2018-07-26T00:00:00+00:00
In the last post</a> I hinted towards how I used docker-compose to run all the services I need on my server. Since someone asked me to describe it in a little more detail I'll do just that in this post. It would probably also make sense to document it a bit for myself as I know that I'm going to forget parts of it at some point 🙈</p>
The basic gist is that everything runs in a docker container and exposes only what's necessary to the public web (and not directly by itself). Using docker to orchestrate everything has the benefit of not having to worry about dependencies or unsupported systems (to a certain degree at least) and leads to minimal overhead when trying out new stuff or updating existing services.</p>
On a sidenote: I host my stuff on a VM provisioned from Hetzner</a>. I used to host all my stuff on Digital Ocean, but I recently ran into hardware limitations for the price class I was willing to pay and had a look around. Hetzner's pricing is by far the best I could find, their servers are located in Germany (EU is a must for me) and their relatively new VM offering has a pretty site as well that looks just like a DO ripoff 😅</p>
traefik</h1>
Holding most of it together is the fantastic traefik</a>, a simple reverse-proxy with everything built-in that I need here. It runs in it's own docker container and comes with a minimal config that I'll go into in a second. The reason I run it at all is because it comes with two amazing features that make it perfect for the job:</p>

For one it connects directly to the docker socket on the host machine and therefore discovers new services instantly and by itself.</li>
It automatically handles registering TLS certificates with Let's Encrypt with literally zero</em> overhead on my end.</li>
</ul>
What we're going to do is configure a docker network - let's call it web</em> - that every service will be placed into that's actually connected to the internet. Since this network will be service agnostic we'll create it as an external network directly with the docker cli.</p>
$</span> docker</span> network</span> create</span> web</span></span></code></pre>
Now we can create a new docker-compose file for traefik that looks something like this.</p>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
</span>
s</span>ervices</span>:</span></span>
  a</span>pp</span>:</span></span>
    i</span>mage</span>:</span> t</span>raefik</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    p</span>orts</span>:</span></span>
      -</span> "</span>80:80</span>"</span></span>
      -</span> "</span>443:443</span>"</span></span>
      -</span> "</span>8080:8080</span>"</span></span>
    v</span>olumes</span>:</span></span>
      -</span> /</span>var/run/docker.sock:/var/run/docker.sock:ro</span></span>
      -</span> .</span>/traefik.toml:/traefik.toml</span></span>
      -</span> ~</span>/data/traefik/acme.json:/acme.json</span></span>
    n</span>etworks</span>:</span></span>
      -</span> w</span>eb</span></span>
</span>
n</span>etworks</span>:</span></span>
  w</span>eb</span>:</span></span>
    e</span>xternal</span>:</span> true</span></span></code></pre>
This describes a new service based on the official traefik image, which is restarted automatically if it stops, exposes ports 80 (HTTP), 443 (HTTPS) and 8080 (dashboard) directly, has a few mounted volumes and is part of the web</em> network. For the network to be picked up by docker-compose we need to explicitly list it in a networks section below.</p>
Ports 80 and 443 are pretty self explanatory, but 8080 is where traefik hosts its own dashboard by default. You can also choose to go about that differently, but that's the traefik default. I actually configured the dashboard to be shown on port 443 of a subdomain of my choosing behind a basic auth challenge, so that it's not entirely open to the public, but you can do whatever you like.</p>
By mounting /var/run/docker.sock:ro</code> into the container we give traefik access to information on all running containers on the host as I mentioned previously, read-only however. In acme.json</code> traefik stores the Let's Encrypt certificate date. We also mount an additional config file, traefik.toml</code>, the contents of which are also relatively simple.</p>
debug</span> =</span> false</span></span>
logLevel</span> =</span> "</span>ERROR</span>"</span></span>
</span>
defaultEntryPoints</span> =</span> [</span>"</span>http</span>"</span>,</span> "</span>https</span>"</span>]</span></span>
</span>
[</span>web</span>]</span></span>
#</span> Port for the status/dashboard page</span></span>
address</span> =</span> "</span>:8080</span>"</span></span>
</span>
[</span>entryPoints</span>]</span></span>
    [</span>entryPoints</span>.</span>http</span>]</span></span>
    address</span> =</span> "</span>:80</span>"</span></span>
        [</span>entryPoints</span>.</span>http</span>.</span>redirect</span>]</span></span>
        entryPoint</span> =</span> "</span>https</span>"</span></span>
</span>
    [</span>entryPoints</span>.</span>https</span>]</span></span>
    address</span> =</span> "</span>:443</span>"</span></span>
    [</span>entryPoints</span>.</span>https</span>.</span>tls</span>]</span></span>
</span>
[</span>retry</span>]</span></span>
</span>
[</span>docker</span>]</span></span>
endpoint</span> =</span> "</span>unix:///var/run/docker.sock</span>"</span></span>
domain</span> =</span> "</span>kilian.io</span>"</span></span>
watch</span> =</span> true</span></span>
exposedByDefault</span> =</span> false</span></span>
</span>
[</span>acme</span>]</span></span>
email</span> =</span> "</span>me@kilian.io</span>"</span></span>
storage</span> =</span> "</span>acme.json</span>"</span></span>
entryPoint</span> =</span> "</span>https</span>"</span></span>
onHostRule</span> =</span> true</span></span>
    [</span>acme</span>.</span>httpChallenge</span>]</span></span>
    entryPoint</span> =</span> "</span>http</span>"</span></span></code></pre>
There's not a lot to say about this. We configure the log level, the default entry points and a redirect to always use TLS. Additionally we tell traefik about the base domain and also about how to handle TLS and and which challenge to use.</p>
The only thing left to do now is to setup your domains DNS records to point to your server's IP address and ideally set up a wildcard subdomain, e.g. *.kilian.io</code> in my case to point to the server as well. This allows you to specify any necessary subdomains directly (blog.kilian.io runs on GitHub pages for example, not my server) and let everything else fall back to the server and therefore into traefik's hands.</p>
Don't forget to boot up traefik via docker-compose from within it's directory and we're good to go ✨</p>
$</span> docker-compose</span> up</span> -</span>d</span></span></code></pre>Running Other Services</h1>
As examples we're going to configure two web-facing services. Instances of gitea</a> and huginn</a>.</p>
Gitea</h2>
Gitea is rather easy to set up, since it requires no other services besides itself. Let's go straight for the docker-compose file.</p>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
</span>
s</span>ervices</span>:</span></span>
  a</span>pp</span>:</span></span>
    i</span>mage</span>:</span> g</span>itea/gitea:latest</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> U</span>SER_UID=1000</span></span>
      -</span> U</span>SER_GID=1000</span></span>
    n</span>etworks</span>:</span></span>
      -</span> w</span>eb</span></span>
    v</span>olumes</span>:</span></span>
      -</span> ~</span>/data/gitea:/data</span></span>
    p</span>orts</span>:</span></span>
      -</span> "</span>2221:22</span>"</span></span>
    l</span>abels</span>:</span></span>
      -</span> "</span>traefik.enable=true</span>"</span></span>
      -</span> "</span>traefik.backend=gitea</span>"</span></span>
      -</span> "</span>traefik.docker.network=web</span>"</span></span>
      -</span> "</span>traefik.frontend.rule=Host:git.kilian.io</span>"</span></span>
      -</span> "</span>traefik.port=3000</span>"</span></span>
</span>
n</span>etworks</span>:</span></span>
  w</span>eb</span>:</span></span>
    e</span>xternal</span>:</span> true</span></span></code></pre>
All we need to do is declare two env vars, the network this container will be added to, a volume for persisting data beyond container restarts and rebuilds, specifically for gitea a custom SSH port and most importantly a few labels.</p>
These labels are what traefik uses to understand how to channel traffic to this container. The last two are the most important ones. First we tell traefik which host header to look for in requests to the server (here: git.kilian.io) and then which port this service wants to map to port 80 / 443 on that domain.</p>
That's it. A request to git.kilian.io (or directly to the server with a fitting host header field) will be forwarded to port 3000 of this service. All you have to do is start it up.</p>
$</span> docker-compose</span> up</span> -</span>d</span></span></code></pre>
TLS is configured automatically by traefik on the first request (which might therefore take a second longer). You should be seeing a valid certificate if everything is set up correctly.</p>
Huginn</h2>
Huginn is slightly more complex since we're going to need two services. The application itself and a database.</p>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
</span>
s</span>ervices</span>:</span></span>
  a</span>pp</span>:</span></span>
    i</span>mage</span>:</span> h</span>uginn/huginn</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    n</span>etworks</span>:</span></span>
      -</span> w</span>eb</span></span>
      -</span> i</span>nternal</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> P</span>OSTGRES_PORT_5432_TCP_ADDR=db</span></span>
      -</span> P</span>OSTGRES_PORT_5432_TCP_PORT=5432</span></span>
      -</span> H</span>UGINN_DATABASE_ADAPTER=postgresql</span></span>
      -</span> H</span>UGINN_DATABASE_USERNAME=huginn</span></span>
      -</span> H</span>UGINN_DATABASE_PASSWORD=...</span></span>
      -</span> T</span>IMEZONE=Berlin</span></span>
    v</span>olumes</span>:</span></span>
      -</span> ~</span>/data:/server/data</span></span>
    l</span>abels</span>:</span></span>
      -</span> "</span>traefik.enable=true</span>"</span></span>
      -</span> "</span>traefik.backend=huginn</span>"</span></span>
      -</span> "</span>traefik.frontend.rule=Host:huginn.kilian.io</span>"</span></span>
      -</span> "</span>traefik.port=3000</span>"</span></span>
      -</span> "</span>traefik.docker.network=web</span>"</span></span>
</span>
  d</span>b</span>:</span></span>
    i</span>mage</span>:</span> p</span>ostgres</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    n</span>etworks</span>:</span></span>
      -</span> i</span>nternal</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> P</span>OSTGRES_USER=huginn</span></span>
      -</span> P</span>OSTGRES_PASSWORD=...</span></span>
    v</span>olumes</span>:</span></span>
      -</span> ~</span>/data/huginn/db:/var/lib/postgresql/data</span></span>
</span>
n</span>etworks</span>:</span></span>
  i</span>nternal</span>:</span></span>
  w</span>eb</span>:</span></span>
    e</span>xternal</span>:</span> true</span></span></code></pre>
The key difference is that we obviously need to create both services, the main application and a postgres database. Since docker-compose doesn't place both of these containers in a new network of their own by default if</strong> there's already a network present (the web</em> network), we also have to explicitly create a new network (I'm calling it internal</em>) so that these services can connect to each other. Notice however how the database is not</em> a part of the web network, there's no reason for it to be accessible from the outside.</p>
And that's also already it for this case as well 👌</p>
Conclusion</h1>
Running applications including any other services they might depend on behind a reverse-proxy taking care of TLS and only exposing necessary stuff to the web should no longer be an issue. The main complexity for setting up new services lies in... well... setting them up correctly. Most well designed</a> applications allow this to be done by setting a few environment variables, making our setup via docker-compose extremely straight-forward and easy to replicate.</p>
Persistence is easily solved via docker volumes</a> or volume mounts. I prefer the latter, even though they lead to a few permission issues here and there and are not host-os-agnostic. I suggest having a look at volumes, there are quite a few advantages. It's just a tiny bit more effort to backup and transfer your persisted data.</p>
I also suggest storing your service's docker-compose files and other configs (like the traefik.toml) in a git repo (obviously not public), which makes setup on a new machine even easier.</p>
🖖</p>


Paperless
2018-07-20T12:00:00+02:00
For the past few years I've been scanning all paper correspondence, be that something I receive via snail-mail, invoices, contracts or whatever else. This has been a huge improvement over not doing so. Before I had troubles finding documents when I needed them and usually had them lying around at home, not at hand when necessary.</p>
Both of these issues are easily resolvable by having digital copies. They can be accessed remotely and are searchable. OCR software has gotten pretty fantastic as well, making it possible to search for certain keywords even in pretty bad scans.</p>
Having used Evernote as a backing store for this database for years now, I've become rather dissatisfied with that platform. It's slow, it's primarily suited for different use cases and it's gotten expensive as well. So I decided to migrate to something else, using the very cool software paperless</a>. Here's a short overview of my workflow using paperless.</p>
Setup</h1>
I rent a VM to run most of the web-based application I use. Every application is managed via a docker-compose file. This makes it trivial to manage services with very different architectures, including paperless.</p>
The docker-compose file looks something like the following. Please note that I did leave out a few details that are very specific to my setup, this won't work as is</em>. You're at least going to have to manage exposing port 8000 of the server service.</p>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
</span>
s</span>ervices</span>:</span></span>
  s</span>erver</span>:</span></span>
    i</span>mage</span>:</span> d</span>anielquinn/paperless</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    v</span>olumes</span>:</span></span>
      -</span> /</span>path/to/your/data:/usr/src/paperless/data</span></span>
      -</span> /</span>path/to/your/media:/usr/src/paperless/media</span></span>
      -</span> /</span>path/to/your/consume:/consume</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> P</span>APERLESS_OCR_LANGUAGES=deu</span></span>
    c</span>ommand</span>:</span> [</span>"</span>runserver</span>"</span>,</span> "</span>0.0.0.0:8000</span>"</span>]</span></span>
</span>
  c</span>onsumer</span>:</span></span>
    i</span>mage</span>:</span> d</span>anielquinn/paperless</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    d</span>epends_on</span>:</span></span>
      -</span> s</span>erver</span></span>
    v</span>olumes</span>:</span></span>
      -</span> /</span>path/to/your/data:/usr/src/paperless/data</span></span>
      -</span> /</span>path/to/your/media:/usr/src/paperless/media</span></span>
      -</span> /</span>path/to/your/consume:/consume</span></span>
    c</span>ommand</span>:</span> [</span>"</span>document_consumer</span>"</span>]</span></span></code></pre>
Here I instantiate two services based on the same image, one running the paperless webserver, one running the paperless consumer service, which watches for new files in its consume directory. Paperless has three options of adding new files.</p>

The consumer watches a directory and adds new files from there, removing them afterwards.</li>
The consumer watches your mail account and adds files from specific emails.</li>
New files are added via a POST request to the HTTP API.</li>
</ul>
I'm also not a huge fan of docker volumes, although they might have a few advantages. Mounting directories is easier to manage imho 🙈</p>
Workflow</h1>
So now we have paperless running and keeping watch over the consume directory, automatically adding new files when you add them. At this point you should take a moment and get acquainted with paperless itself. If you've ever seen a Django admin interface, this will feel very familiar, because that's exactly what it is. That does feel a bit hacky, but it seems to work good enough. You might also want to have a look at this electron desktop app</a> which uses paperless' API to show all scanned documents in a prettier fashion. Unfortunately it seems to only run on macOS at the moment</del> 1</a></sup> and it is an alpha, but it's definitely a great start! It also allows drag and drop of PDF files to upload them.</p>
</p>
The current setup might now already work out great for you, depending on how you scan files and are able to upload files to the consume directory. I'm very used to using a scanning app on my mobile device though, specifically Scanbot</a>. Scanbot has the great feature of letting you upload finished scans to a service of your choice, including FTP and WebDAV shares. This seemed like a great choice to push scans directly to my server. I don't have an FTP server running (and don't want to), but WebDAV is a core feature of Nextcloud</a>. And I do have a Nextcloud instance on my server as well.</p>
What I ended up with is the Nextcloud docker container having the consume directory mounted. Then I enabled the fantastic Nextcloud app allowing external storage, added said directory directly to Nextcloud and then configured Scanbot to upload scans via WebDAV directly to the paperless consume directory. An added bonus is that the Nextcloud desktop client also syncs the consume directory to my computer, so I also have a directory there where I can drop PDF files to be added to paperless 👌</p>
Everything now works rather seamlessly and I have better control of my files than with Evernote. The only thing missing would be a dedicated mobile app to search for scans. Maybe I'll have a go at that 😊</p>



I've been told that this is no longer the case. Thanks Julius! ↩</a></p>
</li>
</ol>
</section>


Chat Statistics
2018-07-02T00:00:00+00:00
I recently stumbled across yet another statistics from my chat with my girlfriend</em> post on /r/dataisbeautiful</a> so today I wanted to evaluate some simple data myself. Unfortunately I'm quite far from being an actual datascientist</a> (below you'll see some of the first matplotlib plots I've ever made), so I'm going to focus a bit more on data acquisition and some very simple findings and visualizations.</p>
Since I probably don't have any chats quite as active as the one with my girlfriend that seemed to be the obvious choice to analyze as well. Unfortunately it's not just one</em> chat, but split across four different messaging platforms since the inception of our relationship ~2.5 years ago. We started out using WhatsApp</em>, then switched to Telegram</em>, then to iMessage</em> and back to Telegram</em> interspersing everything with a bit of random images and answers to those on Instagram</em>. I'd love to turn this into a discussion on the pros and cons of various messaging platforms, but this is neiter the time nor the place. You can hit me up via Matrix (@kiliankoe:matrix.org) if you're interested in going down that route with me.</p>
Accessing the Data</h2>
First things first, we need to actually get our hands on the chat data. This used to be rather tricky depending on the platform, but recently you might've heard some stir about the GDPR. A big upside to that is that I can go around to everybody that stores data on me and my behalf and ask nicely for a machine-readable export of said data. Instagram and Telegram recently implemented export features (Telegram finally doing so just a few days ago, perfect timing). WhatsApp seems to have featured an export for single chats for quite some time, which is nice. iMessage on the other hand is a bit more tricky. The chat data wasn't included in my downloadable copy from Apple's privacy portal</a>, which I assume is due to the fact that all messages are end-to-end encrypted and only accessible from my local devices. Thankfully all message data is available in ~/Library/Messages/chat.d</code> on my Mac, which is just another normal SQLite db.</p>
Time to fire up a Jupyter notebook1</a></sup> and consolidate everything 🎉</p>
I was expecting to run into a few (albeit minor) problems doing this, so it came as no surprise when WhatsApp included quite a bit of random unicode chars to stumble over in it's exported CSV. Interestingly enough Instagram was the least problematic with a well-formatted JSON file, you just have to find the correct conversation. Same goes for Telegram, which throws all</em> conversations into a single file, but it's not like a 15MB file will stop us.  Interestingly enough Telegram also doesn't use UTC timestamps for the message dates, but your local timezone, so watch out and adjust accordingly2</a></sup>. Timestamps are also an issue on the iMessage end, since they seem to be a unix timestamp accurate to nanoseconds but offset 31 years into the past. I have no clue why, but would love to know.</del>
iMessage uses NTP timestamps, thanks to Johannes K. for telling me about that! 😊</p>
Having worked around all those issues I aggregated data on the message date, author, text, platform and type (message, attachment, sticker, voice/video) and created one big CSV sorted chronologically containing the entirety of our digital conversation since we've met. 62k messages that fit nicely into 5.7MB.</p>
What Can We Learn</h2>
I'm not all too interested in sharing exact data on our relationship, so please regard that as being a side effect. Instead I wasn't able to find any fun writeups showing a bit of sample code as well, which is the main reason for this blog post. Unfortunately though the codesamples below are far from ideal, but the beauty of doing something like this in a Jupyter notebook is that the performance costs start to become negligible since you're only running the current cell. Everything else that's already been computed 3</a></sup> just stays in memory. A seriously awesome feature.</p>
So, now that everything is cleaned up and structured nicely we can ask some questions.</p>
Who wrote the most messages in total?</strong></p>
her</span> =</span> [</span>msg</span> for</span> msg</span> in</span> msgs</span> if</span> msg</span>[</span>'</span>author</span>'</span>]</span> ==</span> '</span>her</span>'</span>]</span></span>
me</span> =</span> [</span>msg</span> for</span> msg</span> in</span> msgs</span> if</span> msg</span>[</span>'</span>author</span>'</span>]</span> ==</span> '</span>me</span>'</span>]</span></span>
</span>
print</span>(</span>'</span>her:</span>'</span>,</span> len</span>(</span>her</span>)</span>,</span> len</span>(</span>her</span>)</span> /</span> len</span>(</span>msgs</span>)</span> *</span> 100</span>)</span></span>
print</span>(</span>'</span>me:</span>'</span>,</span> len</span>(</span>me</span>)</span>,</span> len</span>(</span>me</span>)</span> /</span> len</span>(</span>msgs</span>)</span> *</span> 100</span>)</span></span>
</span>
#</span> her: 35152 56.588161432090025</span></span>
#</span> me: 26967 43.411838567909975</span></span></code></pre>
Looks like my girlfriend takes the lead with an 8k message headstart, which accounts to 56% of all messages. Could that be due to me writing longer messages instead? 🤔</p>
How's the average count of words per message per person?</strong></p>
import</span> re</span></span>
</span>
wordcount_her</span> =</span> 0</span></span>
for</span> msg</span> in</span> her</span>:</span></span>
    count</span> =</span> len</span>(</span>re</span>.</span>findall</span>(</span>r</span>'</span>\w</span>+</span>'</span>,</span> msg</span>[</span>'</span>text</span>'</span>]</span>)</span>)</span></span>
    wordcount_her</span> +=</span> count</span></span>
print</span>(</span>'</span>her</span>'</span>)</span></span>
print</span>(</span>'</span>words total:</span>'</span>,</span> wordcount_her</span>)</span></span>
print</span>(</span>'</span>avg words/msg:</span>'</span>,</span> wordcount_her</span> /</span> len</span>(</span>her</span>)</span>)</span></span>
</span>
wordcount_me</span> =</span> 0</span></span>
for</span> msg</span> in</span> me</span>:</span></span>
    count</span> =</span> len</span>(</span>re</span>.</span>findall</span>(</span>r</span>'</span>\w</span>+</span>'</span>,</span> msg</span>[</span>'</span>text</span>'</span>]</span>)</span>)</span></span>
    wordcount_me</span> +=</span> count</span></span>
print</span>(</span>'</span>\n</span>me</span>'</span>)</span></span>
print</span>(</span>'</span>words total:</span>'</span>,</span> wordcount_me</span>)</span></span>
print</span>(</span>'</span>avg words/msg:</span>'</span>,</span> wordcount_me</span> /</span> len</span>(</span>me</span>)</span>)</span></span>
</span>
#</span> her</span></span>
#</span> words total: 216606</span></span>
#</span> avg words/msg: 6.16198224852071</span></span>
</span>
#</span> me</span></span>
#</span> words total: 198979</span></span>
#</span> avg words/msg: 7.378610894797345</span></span></code></pre>
Aha! It might not be a huge difference, but it looks like my messages are bit longer on average. That evens things out 😄</p>
What are our most used words?</strong></p>
from</span> collections</span> import</span> defaultdict</span></span>
</span>
all_words</span> =</span> defaultdict</span>(</span>lambda</span>:</span> 0</span>)</span></span>
for</span> msg</span> in</span> msgs</span>:</span></span>
    for</span> word</span> in</span> re</span>.</span>findall</span>(</span>r</span>'</span>\w</span>+</span>'</span>,</span> msg</span>[</span>'</span>text</span>'</span>]</span>)</span>:</span></span>
        all_words</span>[</span>word</span>.</span>lower</span>(</span>)</span>]</span> +=</span> 1</span></span>
</span>
for</span> word</span> in</span> sorted</span>(</span>all_words</span>,</span> key</span>=</span>all_words</span>.</span>get</span>,</span> reverse</span>=</span>True</span>)</span>[</span>:</span>20</span>]</span>:</span></span>
    count</span> =</span> all_words</span>[</span>word</span>]</span></span>
    print</span>(</span>f</span>'</span>{</span>word</span>}</span>: </span>{</span>count</span>}</span>'</span>)</span></span>
</span>
#</span> ich: 16674</span></span>
#</span> das: 9469</span></span>
#</span> nicht: 7650</span></span>
#</span> und: 7323</span></span>
#</span> ist: 7258</span></span>
#</span> die: 6828</span></span>
#</span> du: 5920</span></span>
#</span> aber: 5831</span></span>
#</span> auch: 5824</span></span>
#</span> dann: 4805</span></span>
#</span> so: 4707</span></span>
#</span> noch: 4611</span></span>
#</span> hab: 4445</span></span>
#</span> der: 4328</span></span>
#</span> d: 4285</span></span>
#</span> ja: 4201</span></span>
#</span> da: 3098</span></span>
#</span> wir: 2969</span></span>
#</span> in: 2930</span></span>
#</span> mal: 2901</span></span></code></pre>
Not the most interesting of results to be honest. Interestingly enough though the distribution looks pretty much the same if you go by person, so I'm willing to believe that this might be a relatively normal distribution for most German speakers. The "d" by the way is probably part of ":D" which the regex just found as being it's own word. Oh well ¯\_(ツ)_/¯</p>
A much better query here would probably be to see which words are specific (or at least more</em> specific) to one person instead of the other. I'm not quite sure how to go about doing that though 🙈</p>
How many messages are sent per day and how many days are there without any messages at all?</strong></p>
all_days</span> =</span> set</span>(</span>)</span></span>
for</span> msg</span> in</span> msgs</span>:</span></span>
    date</span> =</span> msg</span>[</span>'</span>date</span>'</span>]</span>.</span>strftime</span>(</span>'</span>%Y-%m-</span>%d</span>'</span>)</span></span>
    all_days</span>.</span>add</span>(</span>date</span>)</span></span>
</span>
print</span>(</span>len</span>(</span>all_days</span>)</span>)</span></span>
</span>
current_day_count</span> =</span> 997</span> #</span> days we've been together as of today</span></span>
print</span>(</span>len</span>(</span>all_days</span>)</span> /</span> current_day_count</span> *</span> 100</span>)</span></span>
</span>
print</span>(</span>'</span>messages per day:</span>'</span>,</span> len</span>(</span>msgs</span>)</span> /</span> len</span>(</span>all_days</span>)</span>)</span></span>
</span>
#</span> 959</span></span>
#</span> 96.18856569709128</span></span>
#</span> messages per day: 64.77476538060479</span></span></code></pre>
Looks like there's been 38 days without any messages, which comes to down to around 4% of all 997 days. On average there's 64.8 messages a day over the entire timespan. Splitting this up into a running average would probably make a lot of sense.</p>
How many messages are sent per weekday?</strong></p>
This might actually be a good usecase to try and plot something instead. Visualizing these numbers helps put everything into a bit more perspective.</p>
day_of_week</span> =</span> defaultdict</span>(</span>lambda</span>:</span> 0</span>)</span></span>
for</span> msg</span> in</span> msgs</span>:</span></span>
    day</span> =</span> msg</span>[</span>'</span>date</span>'</span>]</span>.</span>strftime</span>(</span>'</span>%A</span>'</span>)</span></span>
    day_of_week</span>[</span>day</span>]</span> +=</span> 1</span></span>
</span>
xs</span> =</span> [</span>'</span>Monday</span>'</span>,</span> '</span>Tuesday</span>'</span>,</span> '</span>Wednesday</span>'</span>,</span> '</span>Thursday</span>'</span>,</span> '</span>Friday</span>'</span>,</span> '</span>Saturday</span>'</span>,</span> '</span>Sunday</span>'</span>]</span></span>
ys</span> =</span> [</span>day_of_week</span>[</span>d</span>]</span> for</span> d</span> in</span> xs</span>]</span></span>
</span>
plt</span>.</span>figure</span>(</span>figsize</span>=</span>(</span>8</span>,</span>5</span>)</span>)</span></span>
plt</span>.</span>bar</span>(</span>xs</span>,</span> ys</span>)</span></span>
plt</span>.</span>title</span>(</span>'</span>Messages per Day of Week</span>'</span>)</span></span>
plt</span>.</span>ylabel</span>(</span>'</span>Message Count</span>'</span>)</span></span>
plt</span>.</span>xscale</span></span>
plt</span>.</span>show</span>(</span>)</span></span></code></pre>
</p>
Also not a surprise, since we usually spend a lot more time together on weekends making digital conversation obsolete.</p>
What about hours of the day instead?</strong></p>
hour_of_day</span> =</span> defaultdict</span>(</span>lambda</span>:</span> 0</span>)</span></span>
for</span> msg</span> in</span> msgs</span>:</span></span>
    hour</span> =</span> msg</span>[</span>'</span>date</span>'</span>]</span>.</span>strftime</span>(</span>'</span>%H</span>'</span>)</span></span>
    hour_of_day</span>[</span>hour</span>]</span> +=</span> 1</span></span>
</span>
xs</span> =</span> sorted</span>(</span>hour_of_day</span>.</span>keys</span>(</span>)</span>)</span></span>
ys</span> =</span> [</span>hour_of_day</span>[</span>h</span>]</span> for</span> h</span> in</span> xs</span>]</span></span>
</span>
plt</span>.</span>figure</span>(</span>figsize</span>=</span>(</span>8</span>,</span>5</span>)</span>)</span></span>
plt</span>.</span>bar</span>(</span>xs</span>,</span> ys</span>)</span></span>
plt</span>.</span>title</span>(</span>'</span>Messages per Hour of Day</span>'</span>)</span></span>
plt</span>.</span>ylabel</span>(</span>'</span>Message Count</span>'</span>)</span></span>
plt</span>.</span>show</span>(</span>)</span></span></code></pre>
</p>
To be honest I'm quite surprised that there's any messages at all between 3 and 6am 🙈 I've got no clue how that ever happenend 😄</p>
What about overall activity?</strong></p>
I had no clue how to go about plotting this via matplotlib, so I decided to export the data as a CSV instead of use Apple's Numbers, please don't judge me 😅</p>
Different platforms have different colors and it's overall grouped by week, not single days, which was far too noisy.</p>
messages_per_date</span> =</span> defaultdict</span>(</span>lambda</span>:</span> {</span></span>
    '</span>whatsapp</span>'</span>:</span> 0</span>,</span></span>
    '</span>instagram</span>'</span>:</span> 0</span>,</span></span>
    '</span>telegram</span>'</span>:</span> 0</span>,</span></span>
    '</span>imessage</span>'</span>:</span> 0</span></span>
}</span>)</span></span>
</span>
for</span> msg</span> in</span> msgs</span>:</span></span>
    date</span> =</span> msg</span>[</span>'</span>date</span>'</span>]</span>.</span>strftime</span>(</span>'</span>%Y-%U</span>'</span>)</span></span>
    platform</span> =</span> msg</span>[</span>'</span>platform</span>'</span>]</span></span>
    messages_per_date</span>[</span>date</span>]</span>[</span>platform</span>]</span> +=</span> 1</span></span>
</span>
with</span> open</span>(</span>'</span>activity_platforms_week.csv</span>'</span>,</span> '</span>w</span>'</span>)</span> as</span> file</span>:</span></span>
    w</span> =</span> csv</span>.</span>writer</span>(</span>file</span>,</span> delimiter</span>=</span>'</span>,</span>'</span>)</span></span>
    w</span>.</span>writerow</span>(</span>[</span>'</span>date</span>'</span>,</span> '</span>whatsapp</span>'</span>,</span> '</span>instagram</span>'</span>,</span> '</span>telegram</span>'</span>,</span> '</span>imessage</span>'</span>]</span>)</span></span>
    for</span> week</span> in</span> sorted</span>(</span>messages_per_date</span>)</span>:</span></span>
        whatsapp</span> =</span> messages_per_date</span>[</span>week</span>]</span>[</span>'</span>whatsapp</span>'</span>]</span></span>
        instagram</span> =</span> messages_per_date</span>[</span>week</span>]</span>[</span>'</span>instagram</span>'</span>]</span></span>
        telegram</span> =</span> messages_per_date</span>[</span>week</span>]</span>[</span>'</span>telegram</span>'</span>]</span></span>
        imessage</span> =</span> messages_per_date</span>[</span>week</span>]</span>[</span>'</span>imessage</span>'</span>]</span></span>
        w</span>.</span>writerow</span>(</span>[</span>week</span>,</span> whatsapp</span>,</span> instagram</span>,</span> telegram</span>,</span> imessage</span>]</span>)</span></span></code></pre>
</p>
Conclusion</h2>
Pulling some stats from chats can be a lot of fun! This is also just scratching the surface, there's a lot left to explore. I didn't try and pull any conclusions from the gathered information, but I know that a lot can be gathered from this, and we're basically just accessing the metadata, which each platform has access to, no matter if the data is end-to-end encrypted^{4</a></sup> or not.</p>}
It might also be super interesting to use sentiment analysis to gain more insight into the nature of messages, maybe not explicitly for these shown here, but other chats as well. Or maybe just something as simple as our most used emoji 😜</p>



The new lab mode is super awesome by the way! 😍 ↩</a></p>
</li>

This is probably a major headache if using Telegram whilst traveling, since you basically lose all time information. No clue how one would handle that correctly 🤔 ↩</a></p>
</li>

Including reading in the CSV data which is the only thing here that actually takes a few seconds. ↩</a></p>
</li>

Which would be the case for iMessage and WhatsApp (allegedly). Instagram offers no such thing and Telegram's secret chats are ridiculous, since they lock you to the client where the chat is initiated. ↩</a></p>
</li>
</ol>
</section>


Docker Swift Runtime
2018-01-29T12:25:00+01:00
I recently wrote a small Vapor</a> web app in Swift which I then wanted to deploy on my server inside a docker container. Not having all too much experience with docker my simple Dockerfile looked something like this.</p>
FROM</span> swift:4</span></span>
</span>
COPY</span> .</span> .</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
RUN</span> swift</span> build</span> -</span>-configuration</span> release</span></span>
</span>
ENTRYPOINT</span> [</span>"</span>.build/release/Run</span>"</span>]</span></span>
CMD</span> [</span>"</span>serve</span>"</span>,</span> "</span>--env=production</span>"</span>]</span></span></code></pre>
Whilst this worked perfectly fine, the image size turned out to be a whopping 1.5GB. That didn't quite feel right if for an app as small as mine.</p>
The problem is of course that the swift</code> image contains the entire development environment that we don't actually need anymore after having built the app.</p>
After trying to go the route of automating the build process by using a container dedicated to building the app then extracting everything I needed from that container and building a new one from that I saw that docker actually had this functionality built in. It's called a multistage build and lets you use separate images to perform whatever it is you want to do. In this case use an image for compiling the app and a separate one to actually package up and run the app binary and configs.</p>
The Dockerfile for that case doesn't get a lot more complicated, we just set a second base image after we're done with the first one and copy over the necessary files.</p>
FROM</span> swift:4</span> as</span> build</span></span>
</span>
COPY</span> .</span> .</span></span>
</span>
RUN</span> mkdir</span> -</span>p</span> /build/lib</span> &&</span> cp</span> -</span>R</span> /usr/lib/swift/linux/</span>*</span>.so</span> /build/lib</span></span>
RUN</span> swift</span> build</span> -</span>c</span> release</span> &&</span> mv</span> `</span>swift</span> build</span> -</span>c</span> release</span> -</span>-show-bin-path</span>`</span> /build/bin</span></span>
</span>
FROM</span> ubuntu:16.04</span></span>
</span>
RUN</span> apt-get</span> -</span>q</span> update</span> &&</span> \</span></span>
    apt-get</span> -</span>q</span> install</span> -</span>y</span> \</span></span>
    libatomic1</span> \</span></span>
    libbsd0</span> \</span></span>
    libcurl3</span> \</span></span>
    libicu55</span> \</span></span>
    libxml2</span> \</span></span>
    &&</span> rm</span> -</span>r</span> /var/lib/apt/lists/</span>*</span></span>
</span>
COPY</span> -</span>-from=build</span> /build/bin</span> .</span></span>
COPY</span> -</span>-from=build</span> /build/lib/</span>*</span> /usr/lib</span></span>
COPY</span> -</span>-from=build</span> /Config</span> ./Config</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
ENTRYPOINT[</span>"</span>./release/Run</span>"</span>]</span></span>
CMD[</span>"</span>serve</span>"</span>,</span> "</span>--env=production</span>"</span>]</span></span></code></pre>
To properly set up the second image to run our app we just have to install a few dependencies and copy over the contents of /usr/lib/swift/...</code>. The rest is the same as before.</p>
Since we now no longer store all dev dependencies in our image, we've just made our image ~1.3GB smaller (around 200MB), that's quite the improvement!</p>
To wrap things up even nicer I published the runtime image as kiliankoe/swift-runtime</code></a> so that we can reduce our Dockerfile to the following.</p>
FROM</span> swift:4</span> as</span> build</span></span>
</span>
COPY</span> .</span> .</span></span>
</span>
RUN</span> swift</span> build</span> -</span>c</span> release</span> &&</span> mv</span> `</span>swift</span> build</span> -</span>c</span> release</span> -</span>-show-bin-path</span>`</span> /build/bin</span></span>
</span>
FROM</span> kiliankoe/swift-runtime:latest</span></span>
</span>
COPY</span> -</span>-from=build</span> /build/bin</span> .</span></span>
COPY</span> -</span>-from=build</span> /Config</span> ./Config</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
ENTRYPOINT[</span>"</span>./release/Run</span>"</span>]</span></span>
CMD[</span>"</span>serve</span>"</span>,</span> "</span>--env=production</span>"</span>]</span></span></code></pre>
My image above is still based on ubuntu:16.04</code>, which definitely shouldn't be a necessity and accounts for most of the remaining 200MB. It would be nice to have far slimmer images in the future, based on alpine for example, but for time being the efforts needed seem to be insurmountable</a>.</p>


Reverse Engineering iOS Apps
2017-05-30T12:30:38+02:00
</iframe>
As promised in my last post</a> I wanted to write a post about a talk I recently held at Mobile Camp 2017</a>. I also held the talk again at our local Cocoaheads Meetup on May 24th 2017, this time being recorded on video (Thanks, Ben</a>!). But since the talk is in German, I promised to publish an English summary here as well, so here we go 😊</p>
The slides are online as well and can be found on GitHub Pages</a>. I've linked to most things as well, everything in orange is clickable 😉</p>
What is Reverse Engineering?</h2>
According to Wikipedia</a>:</p>

Reverse engineering, also called back engineering, is the processes of extracting knowledge or design information from anything man-made and re-producing it or re-producing anything based on the extracted information. The process often involves disassembling something (a mechanical device, electronic component, computer program, or biological, chemical, or organic matter) and analyzing its components and workings in detail.</p>
</blockquote>
That's exactly what we're going to do. We have an app that we didn't write ourselves and want to find out what it's doing</em> under the hood. Maybe we're interested in how a certain behavior is built. Or we want to have a look at how the API the app talks to works or what kind of data is being sent to it (perhaps a little too much?). Or we might even be interested in finding out why a certain bug may be occuring.</p>
Whatever our intent, there's a few things we can do to achieve this.</p>
Inside an App</h2>
There's a few things to find in an app. Obviously we have the app itself, meaning some kind of executable and possibly a list of frameworks. Additionally there's some metadata, which in the iOS world mostly comes down to the info.plist. I'd add NSUserDefaults to this as well, although they're not really included within the app, but stored elsewhere. But especially on macOS this is highly interesting, as a lot of apps offer a lot more customization than seemingly possible via their GUI. And finally we also have assets, e.g. bundled images, videos, sounds, fonts, strings and whatever else.</p>
What's Possible</h2>
I'm going to split this up into two cases, one being while the app is running and the other while it isn't.</p>
If the app is running we can on one hand start monitoring the network and intercept everything the app sends and receives. This is where we can figure out how an API the app might be talking to is working. On the other hand we can try and inject code into the app and bend it to our will.</p>
When not having a running app at our disposal we can open it up and see what kind of stuff is lying around in the bundle. We can also dump the binary to gain a lot more insight into what kind of code the app is actually running behind the scenes.</p>
Intercepting Network Calls</h2>
For this we're going to be using a fantastic tool called Charles</a>, but there are also alternatives</a>.</p>
There are plenty</a> of tutorials</a> for this online, so I'm not going to go through this step by step.</p>
The idea is that we can use Charles to intercept anything an app sends to the internet</em> and receives from said internet</em>. Charles has a pretty nifty feature called breakpoints that let us stop on both events and modify the request and response contents inline.
It becomes a bit trickier if the app is using transport encryption, which any sane app should at the very least be doing. If there are no additional measures like certificate pinning at play though we can just tell Charles to use its SSL proxying mode to use our own SSL certificate instead of the original. That way we can just as well listen in on any encrypted requests.</p>
As mentioned though if the app pins to a specific certificate (meaning their app is expecting a specific one, not just any</em> SSL certificate), we're kinda stuck here. And cert pinning is definitely something any app handling sensitive information should be looking in to if not already doing. Man-in-the-middle attacks are commonplace and it's always a good idea to protect your users. There's more than your reputation at stake 😉</strong></p>
The Bundle</h2>
Apps usually bundle more than just their executable. So why not have a look, even if it's just to satisfy our curiosity.</p>
Go ahead and download whatever app you're interested in via iTunes. If you're looking for a specific (older) version, check out my last post</a> on how to do just that. Right click the app in iTunes and select "Show in Finder". Here we can just rename the .ipa file to end in .zip and unpack it. Then we can have a look inside \o/ (Right click an .app and select "Show package contents" to open it).</p>
For most apps there's not all too much we can discover here. You'll most likely be seeing icons and maybe some other media files. Possibly fonts and sounds as well. Obviously depends on the app.</p>
The two apps I looked into in my talk were both related to public transport in Dresden, 'cause I love myself some good public transport data. The first one, Fahrinfo Dresden</a>, bundles an SQLite db containing a list of all stops in Dresden (for autocompletion) including their coordinates. This was definitely a cool resource to stumble across (especially since these coordinates were somewhat hard to gather elsewhere).</p>
The second app, DVB mobil</a>, is the official app our public transport provider publishes. As you might be able to tell by using the app and the performance that shows, this app is not a native app, but although I'd love to very much, this isn't the place to argue about that... The app is built with Ionic</a> (previously known as Cordova - more or less), which means the core logic and pretty much everything is written in JavaScript and not compiled into a native binary. Interestingly enough this means that we're going to be running across the actual source of the app in the bundle. Unfortunately though the app doesn't do all that much that's very interesting to look at, but it's definitely cool to poke around a bit.</p>
Code Injection</h2>
This was the coolest part of the talk in my mind at least. Unfortunately it requires your device to be jailbroken. But once you've stepped past that hurdle, the fun begins.</p>
We're going to be using a fantastic tool called cycript</a> to basically give us a live REPL into an app of our choice. This is suprisingly easy to do and surprisingly powerful as well.</p>
For the talk I ran an app called Jodel, which, if you're unfamiliar with it, is basically a German equivalent of YikYak. I ran the app on my jailbroken iPhone 4 (running a rather old iOS 7.1.2, but that shouldn't be an issue here) and to then get up and running we just have to SSH into our iPhone and run the following.</p>
$</span> cycript</span> -</span>p</span> Jodel</span></span></code></pre>
The -p</code> flag tells cycript to look through all running processes and find the one with the given name. Cycript will now present us with a prompt where we can use its mix of JS and Objective-C to do whatever we want.</p>
One way of getting started is having a look at the current recursive description of the view hierarchy for example.</p>
#</span>></span> UIApp</span>.</span>keyWindow</span>.</span>recursiveDescription</span>.</span>toString</span>(</span>)</span></span></code></pre>
Cycript has a pretty nice way of accessing anything you know a the memory address of.</p>
#</span>></span> var</span> table</span> =</span> new</span> Instance</span>(</span>0xDEADBEEF</span>)</span> //</span> use an actual memory address, duh :P</span></span></code></pre>
I used this to get a handle to the JDLLoadingTableView</code> I found in the recursive description above, which is the main table view showing all "jodels". Then I wanted to find the top-most cell and see if I can change its displayed text and vote count.</p>
#</span>></span> var</span> idx</span> =</span> [</span>NSIndexPath</span> indexPathForRow</span>: </span>0</span> inSection</span>: </span>0</span>]</span></span>
#</span>></span> var</span> cell</span> =</span> [</span>table</span> cellForRowAtIndexPath</span>: </span>idx</span>]</span></span>
#</span>></span> cell</span>.</span>hidden</span> =</span> YES</span> //</span> this worked, so we have a reference to the correct cell</span></span>
#</span>></span> cell</span>.</span>hidden</span> =</span> NO</span></span>
#</span>></span> cell</span>.</span>recursiveDescription</span>.</span>toString</span>(</span>)</span> //</span> we see there's a `contentLabel`</span></span>
#</span>></span> cell</span>.</span>contentLabel</span>.</span>text</span> =</span> "</span>foobar</span>"</span> //</span> yay, it works \o/</span></span>
#</span>></span> cell</span>.</span>voteCountLabel</span>.</span>text</span> =</span> "</span>156</span>"</span> //</span> works as well :)</span></span></code></pre>
Obviously this only changes the display of things though. Once we send an upvote or trigger a refresh in any other way, our changes are obviously going to be reset. For trying to get around that it would make sense to see if we can change things directly in the models the app stores internally, but that's something for another rainy day 😊</p>
Another way of accessing any running instance of whatever class in cycript is the choose</code> function. You just provide it with a name and it hands you all instances of that class it currently finds. And since Jodel uses Fabric, we can just do the following.</p>
#</span>></span> var</span> crashlytics</span> =</span> choose</span>(</span>CLSAnalyticsController</span>)</span></span>
#</span>></span> [</span>crash</span>[</span>0</span>]</span> fabricAPIKey</span>]</span></span></code></pre>
It's also worth noting at this point that cycript is a fantastic way of getting around that pesky certificate pinning mentioned previously, since we can just go ahead and disable that if it's getting in our way. It's especially easy if the app is using a framework like AFNetworking</code>, where we can just set the SSLPinningMode</code> to None</code>.</p>
If you're a developer you might want to think about this. Anything you do on a user's device is something the user can influence. If your app is talking directly to several third-party services and authenticating itself against them, the user of your app will probably be able to find out your API keys (or similar). It might be worth putting something like that behind your own API, so that you can play somewhat of a gatekeeper for most stuff at least. Also please make sure that you're not throwing around sensitive information everywhere. Anything your app can access is something cycript (or similar and/or more malicious tools) can access. Anything that's just lying around unencrypted and way beyond its lifetime is something that will be read by someone unauthorized. It's a terrible</em> idea to store passwords in NSUserDefaults for example. But it's maybe not quite as obvious that things like encryption keys should not be stored in memory indefinitely either, but just when you need them. It's worth talking to someone with a bit more experience regarding this stuff if you want to take it seriously.</p>
Dumping the Binary</h2>
To find out more of what kind of data an app stores and what it's really</em> doing we're going to have to decrypt the actual executable, arguably the most involved</em> part of this post, but it's actually rather straight-forward in acomplishing. The "hard" part lies in interpreting the results.</p>
First off we're going to want to find the location of the app on our device so that we can tell dumpdecrypted where to look. I'm using a fork of dumpdecrypted</a> which also dumps all frameworks, which can come in handy.</p>
$</span> find</span> /var/mobile/Applications/</span> -</span>name</span> '</span>Jodel</span>'</span></span>
$</span> DYLD_INSERT_LIBRARIES=dumpdecrypted.dylib</span> /var/mobile/Applications/[...]/Jodel.app/Jodel</span> #</span> [...] is a placeholder for the app's ID :P</span></span></code></pre>
After doing so we'll see a Jodel.encrypted file lying around. This we can now pull over to our Mac and throw into a tool like Hopper</a> (there's a free trial, which is rather neat) where can look at pretty much everything and try to see what happens where and how by looking at the generated pseudo-code (awesome feature!) or we can dump the encrypted file using class-dump</a> into a header listing everything that exists. This is useful if you already have a faint idea of what you're looking for. In my case this was to find out some stuff about how Jodel generates the HMAC it uses to "sign" every request making it harder to tamper with their API 😉 Props to them for doing it this way by the way!</p>
$</span> class-dump</span> Jodel.decrypted</span> ></span> Jodel.h</span></span></code></pre>
By the way, there's the iOS-Runtime-Headers</a> repo on GitHub which lists header info on all (including private) frameworks in iOS. It's regularly updated when new versions of iOS emerge. Apple has followed the practice of adding frameworks as private variants before publicizing them in future versions, so it's neat to see hints to some upcoming stuff before it actually gets announced at WWDC 😊</p>
Soooo, that more or less brings us to the end of the talk. Thanks for being there, having a look at the video recording or reading this post. You're awesome! I hope that at least some of the information gathered here was of use to you, I definitely learned some stuff when putting it all together. Cheers!</p>
TL;DR</h2>
If your code is running on somebody else's device, they can do whatever they want with it. And there's not really anything you can do to stop that. Make sure to think about this when building your app, but don't worry about it all too much, it's normal 😜</p>


Downloading older iOS app versions with iTunes
2017-05-10T15:04:18+02:00
Update</strong> (2017-09-23):
Apple recently removed the App Store entirely from iTunes (a welcome move), which kinda broke the entire workflow here. It is however still possible to download IPA files to your Mac through the use of Apple Configurator 2</a>.</p>

Buy and download the app via your iOS device</li>
Open Apple Configurator and login under "Account"</li>
Connect your device, then go to "Add" > "Application" and choose the app in question from your purchase history</li>
A dialog will open asking you if you want to overwrite the app or continue in another fashion. As long as this dialog is open, the IPA file will be cached in ~/Library/Group Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps/</code>.</li>
</ol>
This process at least helps with downloading current IPA files. The act of downloading older versions is left as an exercise to the reader. I have to add that I haven't checked if it's still possible, I'm just guessing that it doesn't differ too much from the process outlined below.</p>

I recently held a talk about reverse engineering iOS apps at Mobile Camp 2017</a>. There will be another post about said talk soon, since I'll be holding it again at our local Cocoaheads meetup in a few days, this time with a video recording 😊.</p>
One of my topics was taking a look into an app's bundle, for which I had an app in mind that bundled an interesting SQLite database1</a></sup>. I remembered stumbling across this a little while ago and thought it'd be something nice and small to show. On redownloading the current version of the app I noticed that the SQLite db was still there, but now encrypted 😿. Not wanting to look around for something else to demo I chose to force iTunes to just download an older version of the app instead. Doing so turned out to be rather easy if you're at least somewhat familiar with man-in-the-middle</em> attacking yourself, something I also went over in my talk.</p>
I'm using a tool called Charles</a> for this. I can also recommend the very popular mitmproxy</a>. The idea is the same for both of them, but I'll reference Charles here.</p>
Run your tool of choice and start iTunes. Search for the app you want and click download. Since you don't want the current version you can cancel the download right after that. Now check Charles for a request to *-buy.itunes.apple.com</code>. Since this request is TLS encrypted we're going to enable Charles' SSL Proxying (right-click the request and do so). Let iTunes re-send the request by starting the download again (we still just need it to start, not actually finish downloading). Charles should now show the request in its unencrypted form.</p>
If you view the server's response you'll see a plist file (Apple's XML based "property list" file format). You're looking for a section that looks like the following.</p>
<</span>key</span>></span>softwareVersionExternalIdentifiers</span></</span>key</span>></span></span>
<</span>array</span>></span></span>
<</span>integer</span>></span>813164182</span></</span>integer</span>></span></span>
<</span>integer</span>></span>813305098</span></</span>integer</span>></span></span>
<</span>integer</span>></span>814184616</span></</span>integer</span>></span></span>
<</span>integer</span>></span>814214406</span></</span>integer</span>></span></span>
<</span>integer</span>></span>814369260</span></</span>integer</span>></span></span>
<</span>integer</span>></span>814850256</span></</span>integer</span>></span></span>
<</span>integer</span>></span>817722935</span></</span>integer</span>></span></span>
</</span>array</span>></span></span></code></pre>
This is a list of all versions of the app (or more precisely their IDs), starting with the oldest. Obviously your IDs will most likely differ.</p>

Unfortunately there's no direct way to correlate all of these version identifiers with the app's actual version strings. Apple's servers only tell you the version string when requesting one of these specifically, but more on that in a pinch.</p>
Go ahead and copy an ID. Now check the request tab of that same request. You should be able to find a section that specifies which version iTunes wants to download.</p>
<</span>key</span>></span>appExtVrsId</span></</span>key</span>></span></span>
<</span>string</span>></span>822037669</span></</span>string</span>></span></span></code></pre>
The easiest way in Charles is to now set a breakpoint on this request (right-click → Breakpoints). Restart the download in iTunes and Charles will pop up allowing you to edit the request iTunes sends to Apple before it goes through. This is where you can now insert your copied ID as the value for the just mentioned appExtVrsId</code> field. After clicking "Execute" Charles will also stop the incoming response before allowing iTunes to read it. This includes a field named bundleShortVersionString</code> which contains the human-readable ID. You can abort the response and try again if this wasn't the app version you're looking for.</p>

If it is a version that works for you, great! That's it 🎉. iTunes is downloading the app as we speak and you can then do whatever you want with it. Be aware that any current versions of the app need to be removed from your device if you want to sync it to one.</p>



I'm referring to the app FahrInfo</a> for Dresden. The bundled SQLite db contains a list of all public transport stops including their coordinates, which was used by the app for autocompletion. And if you know me, you know that I'm a sucker</a> for local public transport data. ↩</a></p>
</li>
</ol>
</section>


Keeping Static Images out of your GitHub Repo
2017-04-10T14:12:35+02:00
People love images [citation needed]</em>. Or at least I know I do. And I've previously stated elsewhere that I hate downloading or installing software that doesn't show me any obvious references to its visuals beforehand. I mean come on, it's just a  screenshot, how hard can it be? GIFs or videos get bonus ✨ points. This obviously also goes for CLIs, which doesn't mean you should skimp on man pages and/or good --help</code> documentation, but a link to a "video</em>" powered by asciinema</a> speaks volumes compared to a textual description of usage patterns!</p>
A lot of the tools we use and download nowadays are primarily hosted publicly on GitHub, which is why a good README has become the defacto standard homepage for your project. This</strong> is exactly where your screenshots, GIFs or videos should go. And it's what most people do, which is awesome.</p>
The problem with inline images and GIFs however is that they have to come from somewhere</em> and that somewhere</em> is usually from within the repo (a ./screenshots</code> dir for example). Especially for GIFs though this can quickly bloat your repo by several megabytes 😕</p>
The solution is rather simple, just let GitHub host the static assets instead 🤷‍♀️ There's no obvious direct upload form anywhere, but we can just abuse GitHub's hosting of images for issues for this. The process is fairly simple:</p>

Open a new issue in a repo of your choice (doesn't matter since it won't be part of the URL and we're not going to actually open the issue).</li>
Drag and drop the image into the issue body.</li>
Your browser will upload the image to GitHub's static hosting server and you'll be provided with a public link similar to this one: https://cloud.githubusercontent.com/assets/2625584/24861665/d962d642-1df9-11e7-9bd5-cb4f02c5d0c1.png</code></a></li>
Copypasta that link into your project's README and discard the issue 🙌</li>
</ol>
This is no different than hosting the image somewhere else like imgur, but it just seems logical to let GitHub handle the public remote hosting for the repo including the static assets without forcing them on everybody wanting to clone the repo 👌</p>
Also, I sincerely apologize for a post that's several times longer than it needs to be for a topic so simple 😜</p>


Akronymisierbar
2017-04-08T22:06:26+02:00
I'm a podcast addict. I have been for a few years now and I can't seem to stop. Podcastprofile</a> has a not very current list of all the feeds I'm subscribed to.</p>
With all the content I consume it only seems logical to produce something at some point as well, or at least try. Hendrik</a> and me have had that plan for quite a while if I recall correctly, and two months ago we finally decided to do something about it. So we sat down and hit record. What came out of that is Akronymisierbar</em> (German for acronyminizable</em>, 'cause all good podcast names are acronyminizable 😜), a podcast about everything that comes to our minds, from programming languages (there's a lot about programming languages) to how frogs swallow by using their eyeballs to push food down, although it's generally more technical as both of us have vested interests in all things computer science.</p>
The fourth episode (#003, we're zero-indexed) was uploaded yesterday as of this posting. You can listen to it right here if you want.</p>
</iframe>
(We're probably going to move away from SoundCloud for future episodes, but we'll definitely publish a new last episode with a new feed link on SoundCloud when that happens.)
It's definitely quite fun and if you're based in Dresden, we've got to have you on the show! 😊</p>
Interested? We're listed on iTunes, Fyyd, Bitlove and probably other podcast directories as well. Give us a listen! We're also very much interested in feedback of any kind, preferably via Twitter @akronymisierbar</a> ✌️</p>


Automatically Increment Your Xcode Project's Build Number
2016-11-09T13:43:52+01:00
Those of us who use Xcode to build, run and deploy projects of ours have probably run into an issue where we've forgotten to increment the build number before trying to deploy a project.
In my case the problem is usually iTunes Connect, which doesn't take your app's version (or CFBundleShortVersionString</code>) into account, but only the build number (or CFBundleVersion</code>). The former is the version we usually set (according to semver</a> if you're a good person, although it really doesn't make much of a difference for user-facing versions) to identify the version internally.
If you fail to increment the latter before uploading, iTunes Connect doesn't see this as a new version, which stinks.</p>
A first idea might be having a build phase which just increments that number every time you hit build. The obvious downside being that you're either going to be committing increments of this number and fixing conflicts on merges or running into outdated build numbers if you have multiple people deploying your app. That's no fun.</p>
The best solution I've come across is coupling your build number to the commit count of your project's git repo. This leads to reproducible build numbers also allowing you to track the state of the app (presuming no uncommited changes were present during archival) based on the build. It doesn't however solve the issue we had with automatically incremented build numbers before, so what if we also reset the build number back to a default value right after we finish compiling? That way our build gets its nice identifying build number and we have no build number changes to commit. Sweet.</p>
All we need for that are two run script build phases. One before near the top setting our generated</em> build number and one near the bottom resetting it (before and after Copy Bundle Resources</code> should probably suffice).</p>
For the first one, add the following.</p>
buildNumber</span>=</span>$(</span>git</span> rev-list</span> HEAD</span> |</span> wc</span> -</span>l</span> |</span> tr</span> -</span>d</span> '</span> '</span>)</span></span>
/usr/libexec/PlistBuddy</span> -</span>c</span> "</span>Set :CFBundleVersion </span>$</span>buildNumber</span>"</span> "</span>$</span>{</span>PROJECT_DIR</span>}</span>/</span>$</span>{</span>INFOPLIST_FILE</span>}</span>"</span></span></code></pre>
Here we're utilizing git rev-list</code> to list out all parent commits of the current state, piping that through wc</code> to count the number of lines and removing leading whitespace with tr</code>. This results in our build number that we set using plistbuddy</code>.</p>
The second script is rather similar.</p>
/usr/libexec/PlistBuddy</span> -</span>c</span> "</span>Set :CFBundleVersion DEV</span>"</span> "</span>$</span>{</span>PROJECT_DIR</span>}</span>/</span>$</span>{</span>INFOPLIST_FILE</span>}</span>"</span></span></code></pre>
Same idea, just a hardcoded string DEV</code> instead of a number of commits.</p>
Hopefully this method will save you just that teeny amount of time updating your build number in the future 🙂</p>


Writing Custom Alfred Worklows
2016-10-23T12:42:16+02:00
A friend of mine</a> has recently started automating some of his tasks using Alfred workflows, a feature of Alfred I've been using for years, but have never really thought about using for my own stuff before.</p>
Although they can sometimes come across rather gimicky, Alfred workflows are actually quite powerful. There's a huge amount of possibilities built right in, but in this post I really only want to focus on a short introduction to so called script filters</em>.</p>
Please be aware that workflows are a paid powerpack</a> feature of Alfred. I can definitely recommend the upgrade though!</em></p>
What's a Script Filter</em>?</h2>
On creating a new blank workflow you're presented with an empty page. Here you can add a bunch of stuff, but the most straight-forward thing (in my opinion at least) is a script filter.</p>
</p>
Script filters are input actions, meaning they can be run on certain keywords and with certain arguments. The argument can then be passed on to a given script (hence the name), which does some 🎩🐰✨ and returns some items for Alfred to display.</p>
Alfred has a list of supported default "languages", including bash or zsh, php, ruby, python, perl and applescript. Or you can just choose "External script" and go with whatever you want.</p>
Caveat</strong>: If you're looking to distribute your workflow to others, it might make sense to go with something that they can run natively without having to install additional dependencies. My first workflow was written in Node.js, which unfortunately doesn't come preinstalled on macOS. And then one of the users had an older version running into all kinds of additional errors. On the other hand, if you're writing a wrapper for npm tooling, node will probably be on your user's machines and the language is their tool of choice anyways. It's always a question of your target audience.</p>
What's also noteworthy here is the "Run Behaviour". Alfred defaults to running one instance of your script after each other. That means that if an instance is already running (maybe being rather slow due to a network call or something else), any further user input will only be processed after the first script has finished and a new instance can be started.
My experience has been that this can easily be changed to terminate the previous instance if the users adds additional input for most cases, making things a lot snappier.</p>
Getting Started with a Script Filter</h2>
A user's input is handed over to your script as argv by default, making it trivial to access this with your language of choosing.</p>
To show a list of items in Alfred once you're done you have to do nothing more than output some JSON (or XML) to STDOUT.
Alfred has pretty good documentation</a> on how your outputted data has to be formatted for Alfred to pick it up.</p>
The basic idea is having a list of items with their respective fields. Most of them are pretty self-explanatory or well explained in the docs linked above.</p>
{</span>"</span>items</span>"</span>:</span> [</span></span>
    {</span></span>
        "</span>title</span>"</span>:</span> "</span>An item</span>"</span>,</span></span>
        "</span>subtitle</span>"</span>:</span> "</span>Some description </span>"</span>,</span></span>
        "</span>arg</span>"</span>:</span> "</span>an argument</span>"</span>,</span></span>
        "</span>icon</span>"</span>:</span> {</span></span>
            "</span>path</span>"</span>:</span> "</span>link to an image</span>"</span></span>
        }</span></span>
    }</span>,</span></span>
    //</span>...</span></span>
]</span>}</span></span></code></pre>
Setting an argument is especially helpful for other actions, as this is what is passed on to them. You can also specify different arguments for modifier keys, so a different actions will be passed on if the user holds ⌘ for example.</p>
Alfred also does a lot for you out-of-the-box if you want to list files from your harddrive.</p>
Using a Helper Library</h2>
You'll make your life a lot easier using one of the plentiful alfred-workflow helper libraries out there, surely also for your language of choice.</p>
Two I'd like to highlight are Alfy</a> by Sindre Sorhus (Javascript) and goalfred</a> by Benjamin Herzog (golang).
Both have a fantastic API making your life a lot easier by just passing along the items and setting appropriate attributes.</p>
Something specific to goalfred are the so called complex arguments. It turns out to be rather tricky if you want to pass along specific variables to further actions. Ben and I figured that out together as I was trying to build a workflow showing departures in our local public transport network (DVB in Dresden, Germany).</p>

</iframe>
</p>
When hitting enter on an item I wanted to schedule a notification to be displayed several minutes before the departure. My first implementation included a small Swift app using system APIs to schedule that as it turns out you can't schedule future notifications via applescript 😕
We later figured out how to implement the same functionality directly within the workflow getting rid of the rather cumbersome and awkward first implementation. Ben went ahead and built that directly into goalfred 🙂 A big recommendation goes out to that library.</p>
Using that we can easily throw together a small (albeit useless) workflow script in go greeting the name the user enters or no one if no input is given.</p>
package</span> main</span></span>
</span>
import</span> (</span></span>
    "</span>fmt</span>"</span></span>
</span>
    "</span>github.com/BenchR267/goalfred</span>"</span></span>
)</span></span>
</span>
func</span> main</span>(</span>)</span> {</span></span>
    //</span> Deals with the normalizing issue below.</span></span>
    query</span>,</span> _</span> :=</span> goalfred</span>.</span>NormalizedArguments</span>(</span>)</span></span>
</span>
    defer</span> goalfred</span>.</span>Print</span>(</span>)</span></span>
</span>
    if</span> query</span>[</span>0</span>]</span> ==</span> "</span>"</span> {</span></span>
        goalfred</span>.</span>Add</span>(</span>goalfred</span>.</span>Item</span>{</span></span>
            Title</span>:</span> "</span>Hello world!</span>"</span>,</span></span>
        }</span>)</span></span>
    }</span> else</span> {</span></span>
        goalfred</span>.</span>Add</span>(</span>goalfred</span>.</span>Item</span>{</span></span>
            Title</span>:</span> fmt</span>.</span>Sprintf</span>(</span>"</span>Hello, </span>%s</span> 👋</span>"</span>,</span> query</span>[</span>0</span>]</span>)</span>,</span></span>
        }</span>)</span></span>
    }</span></span>
}</span></span></code></pre>
I would usually compile this running go build <file>.go</code> and setting Alfred to run the binary as an external script, but you can also use a bash script filter to have Alfred run go run <file>.go</code> or the binary, whatever you prefer.</p>
Problems</h2>
A pain point specific to non-ascii-compatible languages is Alfred's handling of special characters. It uses NSTask internally, which results in umlauts for example being split up into their parts before being passed on, meaning ü</code> becomes ¨u</code>. Here</a>'s some more info on that if you're interested and some help on how to re-normalize the user's input.</p>
Something essential I haven't found a good solution for are workflow updates. Some people publish their workflows using Packal</a>, which provides some help with that. There's also a python lib with some magic.
The best solution I've seen this far is how Alfy recommends publishing workflows on npm and linking them to the correct directory on a post-install step. Still not perfect, but definitely interesting.</p>

If you want to check out the source to some workflows, I've published three of mine on GitHub: alfred dvb</a>, alfred mensa</a> and alfred n26</a>.</p>
Got any additional input or cool workflow ideas? Hit me up on Twitter 🙃</p>


WWDC 16
2016-07-02T02:28:11+02:00
Had a fantastic time about two weeks ago at dubdubdeesee in San Francisco. First time at the West Coast and I'm completely blown away by the amount of amazing people and great time we had. This post is going to be a quick recap of my experiences along the way.</p>
After not expecting to receive the scholarship by Apple at all, I unfortunately did not seem to qualify for Apple's Travel Assistance, which meant I had to gather around ~1.5k€ for an unexpected and very sudden trip to San Francisco. Everything worked out though and I can't say I'd regret even a moment of it all!</p>
My flight went on the Saturday before and because I booked the cheapest flight possible at such a late time I only had a 10-hour layover in Munich 😅 Wasn't quite as bad though, my parents live close by and we went for coffee and lunch in the city.</p>
Arriving in San Francisco at 6 pm local time I was picked up by two friends, Ben and Micha, who also came to town for WWDC from Dresden. They had far better flights though without layovers like mine, so they left later, but arrived earlier 😄</p>
We three spent the next day exploring the most known parts of the city. Had a look at Golden Gate from pretty much every angle, went to Fisherman's Wharf and Coit Tower1</a></sup> to name a few.</p>
</p>
Ending the day we headed over to Twin Peaks for the sunset, where the view of the city was amazing! Only downside: It was freakin' freezing! We all had no idea that California even got this cold... No wonder Apple hands out jackets to WWDC attendees.</p>
</p>
I spent most of Sunday at the scholarship orientation that Apple had planned. There were a few interesting talks, lots of time to socialize with other scholars and some Apple employees and for those interested some dedicated selfie time with Tim Cook. I chose to skip that, the crowd was far too intimidating.</p>
The best part was definitely meeting the other scholars and chatting about their backgrounds, projects and other shared interests. The apps some people built for the scholarship were seriously mind-blowing! I definitely had a great time there!</p>
Here's a pic Apple photographers apparently took of Maria, Gustavo and me taking a selfie 😁 The image is straight out of the current version of the official WWDC app. The other pictures in the galleries there are also worth a look!</p>
</p>
Monday was keynote day. Woke up and walked to Bill Graham with Micha at around 5 am. We didn't want to get up too early since the venue was far bigger than Moscone West the previous years. We were confident that 5 was early enough to get fairly good seats.
Turns out though that some Apple employees did their best to round up all scholars though and we got in a bit early and had fantastic seats right up in the in the first three rows at the front left and right.
Micha also had a great seat though, Apple's decision to go with Bill Graham seemed like a very wise choice, it's a huge place.</p>
</p>
I don't have a lot to say about the Keynote or Platforms State of the Union though. Their content is pretty known around the globe by now 😉 I'm just extremely excited to be using the announced features in my OS' as soon as possible and can't wait to build stuff against the new APIs.</p>
The rest of the week at Moscone West was just as great. We definitely had a blast in the sessions and just as much in the labs talking to some Apple engineers about the frameworks we're using and some best practices. Just the atmosphere of having hundreds of developers around me interested in the same topics and building similar things was fantastic! There's not much similar to how much that gets you motivated! 🤗</p>
Our evenings were mostly spent at parties hosted by the great people at Twitter, Microsoft/Xamarin, Mapbox, Lyft and Realm amongst a few others. I especially enjoyed the 1.0 launch party @ Realm HQ! Didn't stay all too long though, since we at least wanted to check out the WWDC bash at Bill Graham as well. Didn't expect such a big concert and I loved the food there!</p>
Here's a few of us at Realm HQ. From right to left: Bilal, Fabian, Ben and me.</p>
</p>
We (Ben, Micha, Fabian and I) took off on Friday afternoon driving a few miles south visiting Facebook HQ (with a great tour from Max!2</a></sup>). Somewhat blown away by their campus to be honest! I was expecting a bigger building but not around 20 of them with all kinds of activities strewn throughout. As much as I despise the platform itself, it seems like an awesome place to work!</p>
Also went by Apple HQ @ 1 Infinite Loop and Google HQ. Unfortunately no tours at both of them, but it was fun walking by nonetheless. Maybe next time? 😁</p>
My last day in the area (Saturday - the others were staying until Tuesday) we (this time it was Ben, Micha, Matt, Max (not the one from FB) and me) spent in Yosemite, a seriously beautiful national park! Great weather and gorgeous views! Had a bit of bad luck though, because Obama and family were also here hiking, so there were a lot of people and we didn't quite get to see everything we came for. Nevertheless definitely worth the 3-hour car ride though!</p>
</p>
And that's pretty much it for my rather short overview of the week. As said before, we had a great time and I'd like nothing more than to be right back here in a year. Let's see if I can make that work!</p>



We didn't want to go up though, as we had no intention of waiting there for roughly 45 minutes. The entire culture of waiting</em> in the US is an aspect that really bothers me by the way. Enter a restaurant and be told that your table will be ready in half an hour? Wat? Not to mention more famous highlights like the DMV 😄 ↩</a></p>
</li>

And another guy whose name I unfortunately did not catch. We had a great time with you guys though! Maybe we'll catch up at 33c3 end of the year? ↩</a></p>
</li>
</ol>
</section>


On Quitting Facebook
2016-06-30T02:24:08+02:00
I’ve been seriously disliking the idea of maintaining a Facebook profile for quite a while now. It adds close to nothing to my life. After having loaded the page it seems I am always being presented with the same content over and over. The newsfeed is completely and utterly useless.</p>
A few months back I chose to delete my personal timeline. Facebook started to show me content from a few years back (from a much younger self) and I was presented with things that I really did not wish to display publicly online. It was nothing bad or deeply embarrassing, but I urge you to scroll all the way to the bottom of your FB profile and just start reading upwards. You'll get what I mean 😉</p>
I couldn't and still can't quite delete the entire profile though. I like the idea of having a social hub out there, a place where someone can enter my name into a search box and then contact me (via Messenger1</a></sup>). And even though I maintain contact with most people via E-Mail and Twitter, there's loads of others out there using FB and nothing else2</a></sup>. And I kinda want to be able to stay in contact with them as well.
In practice my current</em> conversations in there are strewn across the last few months. One from March, one from April, two from June.
So it actually turns out that I have moved most of my conversations away from Messenger, that's nice.</p>
Another aspect I thought I'd miss out on when completely leaving the platform are events. A lot of my contacts plan parties and other events this way. Up until recently I've been using OS X's FB integration (disgusting btw) to throw those into my calendar automatically. Which works to a certain degree. You can't edit or delete events (or invitations), as this apparently is a read-only feed from FB. And when some contacts (you know who you are! 👀) started planning events spanning several months and thus completely spamming my entire calendar, I threw that out.
I have to say... I'm not entirely sure what I've missed in the months since, but I don't think it has been all too much. Every now and then I receive a "Did you see the FB event and invitation?</em>" message, which of course is a little more work on the side of the event organizers (which I regret), but I can't say that it hasn't been working out.</p>
Summing up, neither Messenger nor events have been particularly good reasons to keep the dreaded profile around.</p>
There is however one thing I just can't seem to migrate well. And that's FB groups.
For obvious reasons these are incredibly</strong> popular in my social circles. The ones I check regularly3</a></sup> are a group related to my studies at my university (with tons of inside info, which kinda sucks to miss out on), our local Cocoaheads chapter (Would really welcome to see this someplace else! 😁) and a few others.</p>
After having had this post as a draft for more than a year now, I've still gotten no closer to deleting my profile than deleting timeline contents and disabling posts there by others. But at least my FB usage has come down to a minimum, which is at least a small success. Maybe I will be able to get rid off it entirely at some point in the near future.</p>



I want to give a quick shoutout to messenger.com</a>, a site built by Facebook that contains only the messenger and nothing else. It's actually quite nice! ↩</a></p>
</li>

Came into contact with this again after attending WWDC as a scholarship recipient. Most of the other scholars I talked to were expecting Messenger as a default way of communication. ↩</a></p>
</li>

I can recommend the Groups</a> app for iOS at least. Works rather well. And also has well designed UI gestures. ↩</a></p>
</li>
</ol>
</section>


WWDC 16 Scholarship
2016-05-18T02:21:05+02:00
Apple was gracious enough to grant me a WWDC scholarship this year. I’m still blown away!</p>
</p>
The next challenge is obviously getting to SF. Unfortunately it’s not exactly cheap traveling all the way from Germany, but I’ll find a way. Definitely couldn’t justify missing this one-of-a-kind event.</p>
Stay posted for more, especially once it’s June 😁</p>


Cheap DynDNS Alternative
2016-03-07T02:19:48+02:00
Until recently I had the pleasure of living with a static IP. This made accessing my Raspberry PI from outside my home rather easy. I could just open the port on my router and hardcode the IP anywhere.</p>
After moving though easy access like that unfortunately fell away. I looked into some services like DynDNS but found them cumbersome and hard to work with. A simple solution to this “problem” presented itself via CloudFlare. Why not just get my current IP every $TIME_INTERVAL or so and send that to CloudFlare via their API updating an existing DNS record.</p>
Here’s a simple ruby script for just that.</p>
#</span>! /usr/bin/env ruby</span></span>
</span>
require</span> '</span>net/http</span>'</span></span>
require</span> '</span>cloudflare</span>'</span></span>
</span>
#</span> Email used for login</span></span>
CLOUDFLARE_EMAIL</span> =</span> ENV</span>[</span>"</span>CLOUDFLARE_EMAIL</span>"</span>]</span></span>
</span>
#</span> API Key, can be found here => https://www.cloudflare.com/a/account/my-account</span></span>
CLOUDFLARE_API_KEY</span> =</span> ENV</span>[</span>"</span>CLOUDFLARE_API_KEY</span>"</span>]</span></span>
</span>
#</span> The zone (aka domain) this is for, e.g. 'example.com'</span></span>
CLOUDFLARE_ZONE</span> =</span> ENV</span>[</span>"</span>CLOUDFLARE_ZONE</span>"</span>]</span></span>
</span>
#</span> The specific record name to edit, e.g. 'record.example.com'</span></span>
CLOUDFLARE_RECORD_NAME</span> =</span> ENV</span>[</span>"</span>CLOUDFLARE_RECORD_NAME</span>"</span>]</span></span>
</span>
def</span> get_ip</span></span>
  Net</span>::</span>HTTP</span>.</span>get</span>(</span>URI</span>.</span>parse</span>(</span>'</span>http://canihazip.com/s</span>'</span>)</span>)</span></span>
end</span></span>
</span>
def</span> update_cloudflare</span>(</span>ip</span>)</span></span>
  cf</span> =</span> CloudFlare</span>::</span>connection</span>(</span>CLOUDFLARE_API_KEY</span>,</span> CLOUDFLARE_EMAIL</span>)</span></span>
  begin</span></span>
    rec_id</span> =</span> '</span>'</span></span>
    records</span> =</span> cf</span>.</span>rec_load_all</span>(</span>CLOUDFLARE_ZONE</span>)</span></span>
    records</span>[</span>'</span>response</span>'</span>]</span>[</span>'</span>recs</span>'</span>]</span>[</span>'</span>objs</span>'</span>]</span>.</span>each</span> do</span> |</span>record</span>|</span></span>
      if</span> record</span>[</span>'</span>name</span>'</span>]</span> ==</span> CLOUDFLARE_RECORD_NAME</span></span>
        rec_id</span> =</span> record</span>[</span>'</span>rec_id</span>'</span>]</span></span>
        break</span></span>
      end</span></span>
    end</span></span>
    #</span> Sending '1' for the TTL = 'automatic' meaning approx. 300 (5 minutes)</span></span>
    cf</span>.</span>rec_edit</span>(</span>CLOUDFLARE_ZONE</span>,</span> '</span>A</span>'</span>,</span> rec_id</span>,</span> CLOUDFLARE_RECORD_NAME</span>,</span> ip</span>,</span> 1</span>)</span></span>
  rescue</span> =></span> e</span></span>
    puts</span> e</span>.</span>message</span></span>
  else</span></span>
    puts</span> "</span>Successfully updated A record for </span>#{</span>CLOUDFLARE_RECORD_NAME</span>}</span> to </span>#{</span>ip</span>}</span>"</span></span>
  end</span></span>
end</span></span>
</span>
update_cloudflare</span>(</span>get_ip</span>)</span></span></code></pre>
The script relies on two things to work correctly:</p>

Make sure to set the record to be updated beforehand, this script will look at all records and update the IP of the correct one.</li>
You need to pass a few environment variables as specified at the top of the script, namely CLOUDFLARE_EMAIL</code>, CLOUDFLARE_API_KEY</code>, CLOUDFLARE_ZONE</code> and CLOUDFLARE_RECORD_NAME</code>.</li>
</ul>
Now just periodically run it via cron or however you like 🙂</p>
Setting up the record beforehand also gives you the freedom of specifying if you want CloudFlare tunneling for the record or not. Whatever you set will not be changed by this script.</p>
UPDATE</strong>: Thanks to @stefanmajewsky</a> here</a>’s a Python script for doing the same directly via Gandi.net. Awesome!</p>


Firewatch
2016-02-13T02:17:52+02:00
</p>
Finished it two days ago and was left in some emotional turmoil. I believed the ending to be spoiled for me after accidentally having read a sentence on Reddit, but it turns out that was bullshit. Unfortunately that made it even worse.</p>
It’s a gorgeous game, albeit relatively short (~4 hours). The gameplay mechanics work great (a bit unexpected at times) and the story is definitely captivating. Can’t say too much about it though without giving stuff away.
Definitely recommended! It’s not</strong> a horror game either, just thrilling at times and beautiful at others. Give it a shot! 😊</p>
It’s available for Mac, Windows and PS4. Grab it on Steam here</a>.</p>
</p>


Black Mirror
2016-01-13T02:16:54+02:00
Blindly following a recommendation on Reddit I just finished watching the first season of Black Mirror</a>. Not quite sure what I was expecting, only had the SciFi label in my head. Didn’t quite find that, more of a feeling of deep disgust with the different shown realities. Interesting nonetheless. And definitely a recommendation!</p>


32c3
2016-01-01T02:14:31+02:00
</p>
That was seriously awesome! My first congress and I couldn’t be happier with it. Definitely coming back next year, for sure!</p>
There’s so much I could write about here, but I’m going to keep it to a minimum.
I kinda regret watching quite a few talks live and not using the time at CCH to have a look at most assemblies and workshops. Will improve on that @ 33c3. All talks have since been published online at https://media.ccc.de</a>. Have a look, and come next year! 😊</p>
</p>


HeartBattery
2015-11-20T02:07:50+02:00
A friend recently had the fun idea to write a small script for his machine running Arch displaying his current battery state as a series of hearts instead of the traditional boring percentage. He did so via a short python script and the magic of Font Awesome to integrate with Conky.</p>
I have to admit that writing a quick script in your language of choice makes customization like this a lot easier than on OS X, but I liked the idea and wanted to follow along with something native as well. So today I wrote a little app in Swift titled HeartBattery.</p>
</p>
It doesn’t really do a whole lot besides pulling the state of your battery every five minutes and telling you a few things about it. The hardest part was actually getting the data and generating the image. Getting the data unfortunately isn’t as easy as reading it from a file somewhere like others systems do it, but you have to interface with some rather confusing C APIs. Not really wanting to do that I eventually stumbled across SystemKit</a>, a Swift lib that abstracts all that away and offers an API that couldn’t be much simpler. It’s from the same person behind dshb</a>, that amazingly pretty ncurses powered system monitor for OS X.</p>
Unfortunately it doesn’t seem possible to set a custom font for a status item and multiple images are also not an option (afaik), so I had to resort to compositing a few icons together on every refresh of the app to generate a single wide image for the menubar representing the current battery state. Really doesn’t feel like the cleanest option, but another thing learned can’t be bad either I guess.</p>
If you want to have a look you can find the source and download link on the GitHub repo here</a>. And as usual, if you have any ideas, suggestions or think my code can be improved upon and want to tell me how to pull it off, why not head straight for the issue/pull request 😊</p>
</p>
Now all that’s missing is a bling sound whenever you lose a heart 😄</p>


ParkenDD
2015-02-26T02:01:49+02:00
A few months ago Code for Germany</a> launched. An OK Lab</em> (Open Knowledge Lab</em>) was founded in Dresden soon after, although similar projects (offenesdresden.de</a>) were already in place. Everything merged and Dresden has had quite an active community interested in bringing Open Data to the next level. It's awesome.</p>
My first real contribution to this comes in form of an iPhone app using a PHP scraper backend</a> scraping the data at dresden.de/freie-parplaetze</a>. An Android application for this purpose came to life fairly quickly (find it here</a>), so a clone for iOS just had to follow!</p>
</p>
It shows you whether a public parking lot is closed or not, how many spots are available and where it is on a map.
It's currently waiting for review and will hopefully be on the App Store within a few days. Definitely fun to build and I learned quite a bit more about developing for iOS. Future projects will be even better and more fun to build ;)</p>
The source for this application is available on Github. See https://github.com/kiliankoe/parkendd.</p>
Update</strong>: Apple has just approved the first version of the app. It's available here: https://itunes.apple.com/de/app/parkendd/id957165041</p>


Migrating to kilian.io
2015-01-05T01:59:59+02:00
I spent most of today moving around my e-mail infrastructure</em>. The way I had it configured would probably bring tears to most people's eyes, so I'll spare you the gruesome details. Let's just say that nothing is forwarding to Google Mail any longer and I'll be using a different address as my main contact address from here on out. Namely me@kilian.io</strong>. The domain kilian.io has been pointing to my server at Uberspace</a> for a little while now, but it hasn't been much more than a little gimmick, just like kilian.sexy</a> ;)
I've been starting to enjoy it a lot more than koeltzs.ch though, as it carries more personality, more me</em> than just my last name. And since kilian@kilian.io just looks ridiculous I'm choosing to go with the very informal me@kilian.io instead.</p>
The old</em> domain koeltzs.ch isn't going anywhere any time soon. I'll probably be renewing it as well for the years to come, mails and redirects will still work. Transitioning basically my life's worth of emails is no easy task either, but consider my Google Mail address officially deprecated from here on out.</p>
I've also used this chance to deactivate the catchall for all my domains. Mail bounces aren't necessarily a bad thing and this should also greatly help reduce the amount of spam that hits my mailserver day and night.</p>
My PGP key has also been updated with the new address and I'll soon be transitioning to me@kilian.io for some of my xmpp/jabber conversations as well. Even though my site already states this, that particular change will still take a bit.</p>
I really do have to endorse Fastmail.com</a> somewhere throughout this post. Hosting my own mail server is something I definitely do not</strong> want to do be doing.  I have a tendency not to trust software that I maintain myself (I know that sounds sad) and even more so when I don't understand it all. So even though I'd be able to keep it running, I'm not sure it would be doing so safely or for a very long time. I'm trusting this one with people that make this their living. The recommendation for Fastmail comes from Marco Arment</a>. They've been around for a little while and are doing some really cool things</a> as well, they definitely know what they're doing and are doing it well. And I enjoy paying for something of use to me, highlighting the fact that I'm probably not the product here.</p>
I'm definitely going to run into a few gotchas with this move, I'm sure of that. But I have to be doing this someday. So better nate than lever</a>.</p>
It's actually been a lot of fun and the only thing to change now is the domain for this blog. Unfortunately I can't run this under two domains simultaneously, so I'm going to be making this switch Monday evening (as in today, depending on how current this is when you read it). So if you're one of the few people I know to be subscribed to the feed, please update it to check blog.kilian.io from now on. Thanks :)</p>
Edit: Done :)</p>


Pycharm and Java 8
2014-12-19T01:57:50+02:00
There's been a bug</a> with current versions of Jetbrains products (not just Pycharm, but also IntelliJ IDEA, Android Studio, AppCode and surely the others as well) on OS X 10.10 Yosemite where the editor screen flickers uncontrollably when you scroll the view. It's been making my workflow increasingly difficult and was generally unpleasing, but there is a way around this!</p>
Kudos goes to Justus</a> for pointing this one out.</p>
All you have to do is set your favorite Jetbrains IDE to use the JVM version 1.8 instead of the default 1.6. This is easily done on OS X by editing the Info.plist</code> found at /Applications/<PyCharm.app or something else>/Contents/Info.plist</code> like this.</p>
</p>
Interestingly enough this will also make your Darcula theme a little darker (very pretty) and the font rendering gets a lot better as well. Perfect fix!</p>


Simple Robot
2014-10-31T01:53:35+02:00
It's been a while since I've touched Blender. A lot has changed, everything is awesome. There's not all too much to say, but I'm a real sucker for pretty clay renders, so here's a simple little robot.</p>
</p>
Note that this render is in 2400p, the native resolution of the new MacBook Pro. I didn't want said device to go up in flames though, so a shoutout goes to render.st</a> (and especially their signup bonus).</p>
</iframe>

    Simple Robot</a>
    by kiliankoe</a>
    on Sketchfab</a>
</p>


Installing OS X applications through Homebrew
2014-07-21T01:47:19+02:00
I have to admit to having been slightly jealous of a friend running Arch Linux on his laptop when he went ahead and installed xmind</a> right through his package manager (or actually yaourt</a>, but I won't make the distinction here). Now don't get me wrong, there's nothing wrong with installing applications on OS X. It's dead simple.</p>
</p>
You download the disk image, double-click it to mount and drag the .app onto your linked Applications directory. But it's so graphical... Any self-respecting appleleptic</em> nowadays already has the fantastic Homebrew</a> package manager installed on their system anyways, which is awesome stuff, without question. And there is one package I have to admit to not having heard of before a few days ago, even though it has a rather big following which helps us out here.</p>
It's called Homebrew Cask</a> (you just gotta love the naming scheme of things in the Homebrew universe: Brew, Cask, Formula, Tap, etc) and its sole purpose is allowing you to run commands like brew cask install xmind</code>. It worries about where to get the latest version from, where to put it, and for a few selected applications also how to specifically uninstall them when you run brew cask uninstall app-name</code>. It also doesn't just do apps, but preference panes, quicklook plugins, services, widgets and a few more. It's an allround powertool for installing stuff on your mac that homebrew itself doesn't handle.</p>
So how do you get it?</h3>
Unfortunately cask isn't included in main homebrew repo, but don't despair, that just makes us run one more command.</p>
$ brew tap caskroom/cask</span></span>
$ brew install brew-cask</span></span></code></pre>
Note: You might find others online referencing to tap phinze/cask instead, which isn't wrong, it's just old. Fortunately GitHub redirects phinze/cask to caskroom/cask, but this might stop working one day, so just go with caskroom/cask and you won't have to worry.</p>
Cask is now installed on your system. It's main working directory is /usr/local/Library/Taps/caskroom/homebrew-cask</code>. This is where the git repo resides, which is one of the most awesome facts about homebrew by the way. All of it being just a bunch of ruby scripts and a git repo to manage them. You don't actually need to do anything in this directory though, unless you want to add your own casks, which we'll go over how to do in a sec.</p>
Using cask</h3>
$ brew cask update</span></span></code></pre>
This is basically an alias to git pull origin master</code> in the cask repo and updates your list of available casks to the current status. Running this often is key, as new casks are created and others are updated on a daily basis. Run this if you can't find a cask or before installing one if you haven't updated in a little why to ensure you get the newest version of an application.</p>
$ brew cask search app-name</span></span></code></pre>
Want to know if an app you're looking to install is available through cask? Just run this. The naming strategy is pretty straight forward with everything being lowercase and dashes for spaces. Search also finds partial results, so for example this works:</p>
kilian@Apollo:~$</span> brew</span> cask</span> search</span> intellij</span></span>
=</span>=</span>></span> Partial</span> matches</span></span>
intellij-idea</span>     intellij-idea-ce</span></span></code></pre>$ brew cask install app-name</span></span></code></pre>
Installs an app. Simple. It also automatically runs through any zip files, disk images or packages. It'll prompt you if an admin password is needed.
One thing to note is that applications are by default not</em> installed to /Applications</code>, but to /opt/homebrew-cask/Caskroom/app-name/version/app-name.app</code> and then symlinked to ~/Applications</code>. This is no problem for your mac, but in case you'd like to link it to /Applications</code> instead, run the command like this brew cask install app-name --appdir=/Applications</code>.</p>
$ brew cask uninstall app-name</span></span></code></pre>
This should be about as self-explanatory as it gets. As I mentioned already however this doesn't just remove the application from your system, but for a few special apps that require their own uninstaller to be run, this is done instead.</p>
$ brew cask list</span></span></code></pre>
Lists all your installed casks. If you run it together with an application name it'll tell you which files are installed and where they reside.</p>
$ brew cask cleanup</span></span></code></pre>
Cleans up downloaded files which are usually not removed after installing an application. Might free you up quite a bit of space on your harddrive.</p>
$ brew cask home app-name</span></span></code></pre>
Takes you to the homepage of an application. Be it the developer's site, a GitHub repo or whatnot.</p>
And last but not least, an essential one if you're an Alfred</a>-junkie like me:</p>
$ brew cask alfred link</span></span></code></pre>
This adds the install directory to Alfred's search path so you can find your installed applications with Alfred.</p>
That's actually all there is to using cask. It's a fantastic little application and the list of applications it can install is pretty damn huge</a> (1.723 entries as of now).</p>
There are however two other points I'd like to go over.</p>
Using Brewfiles</h3>
Homebrew includes the wonderful functionality of being able to run a number of commands from a file you specify. This is typically called a Brewfile, but you can name it whatever you want.</p>
This of course finds it main purpose in installing a few packages together and bundle</em> them together.</p>
Using this is extremely simple, here's a Brewfile</a> I set up so I can quickly install all the applications I use regularly on my system if I have to start from scratch (new machine, dead harddrive or ritual cleansing, who knows).</p>
As you can see it just includes a command on each line without the brew</code> command itself.</p>
...</span></span>
install node</span></span>
install ffmpeg</span></span>
...</span></span>
# set up brew cask</span></span>
tap caskroom/cask</span></span>
install brew-cask</span></span>
...</span></span>
# cleanup</span></span>
cask alfred link</span></span>
cleanup</span></span>
cask cleanup</span></span>
...</span></span></code></pre>
Lines starting with a #</code> are comments and will be ignored by homebrew.</p>
Use the command brew bundle filename</code> to let brew run through it. Already installed packages and applications will not be overwritten.</p>
Creating your own casks</h3>
So you found something that's not yet available through cask and want to become one of the 743 current contributors? That's awesome! And it's really quite simple as well. All you need is some basic knowledge how to use git and you're set. Let's take a look.</p>
Let's start by setting up your fork on GitHub. Visit the official repo</a> of cask on GitHub and click on the fork button in the upper right-hand corner. Wait a few seconds and GitHub will create a clone of the repo under your account. We'll use this to change what we want and send a pull request back to main repo.</p>
Now open up a terminal and navigate to the cask repo on your harddrive.</p>
$ cd /usr/local/Library/Taps/caskroom/homebrew-cask</span></span></code></pre>
Let's branch off into a feature branch to add the new cask.</p>
$ git branch add-app-name</span></span>
$ git checkout add-app-name</span></span></code></pre>
Now we can create the cask by running</p>
$ brew cask create app-name</span></span></code></pre>
Please check the naming details</a> before naming your cask. The rest of the contributing guide contains all the following details as well, but I'm going to go through them anyways.</p>
This should immediately open up your default editor where you can go ahead and fill out the details like version number, hash</a> of the download, link to the download, homepage and name of the to be linked file. After saving this you can already go ahead and try it out by installing it yourself. Use brew cask edit app-name</code> to quickly jump back to editing the file again. If you're sure everything works also run brew cask audit app-name --download</code> for some additional checks.</p>
Time to commit. Add your cask and commit it with a sensible message containing the name and version number.</p>
$ git add Casks/app-name.rb</span></span>
$ git commit -m 'Add app-name v0.1'</span></span></code></pre>
Now let's add our fork as a remote so we can push the changes to GitHub with one of the following two commands depending on if you interact with GitHub over SSH (second command) or not (first one).</p>
$ git remote add fork https://github.com/your-username/homebrew-cask.git</span></span>
$ git remote add fork git@github.com:your-username/homebrew-cask.git</span></span></code></pre>
And push it.</p>
$ git push fork add-app-name -u</span></span></code></pre>
You can now visit the main cask repo</a> where a green button to submit your pull request should be greeting you. Click that, check the changed files just to be sure you did what you wanted and submit it. The repo is very active and presuming everything is awesome it shouldn't be long for it to be merged.</p>
Just don't forget to switch back to the master branch in your local cask repo, otherwise you won't be getting future updates ;)</p>
$ git checkout master</span></span></code></pre>
You can also delete your local feature branch if everything is done.</p>
$ git branch -d add-app-name</span></span></code></pre>
You're now officially a contributer to cask, awesome stuff.</p>
This also concludes this post. I hope it was interesting enough and you find cask to be just as useful as many others and I do.</p>


This is getting ridiculous
2014-04-21T01:43:52+02:00
</p>
November 29th, 2012: Left a math lecture on a rainy day and wanted to get home as quick as possible. But it looked like I would be carrying my bike home seeing how some douche had stolen my front wheel on campus. Seeing how I moved to Dresden with quick release skewers</em> (if I can trust dict.leo.org) however, this happening was just a matter of time.
Instead of directly buying a new wheel (and new brakes, thank you, asshole! Oh, and a Pitlock</a> system) I went with a completely new (as in old) and cheap bicycle. Fast forward to January and a few stitches on my face, and I wanted to go back to riding my</em> bike.
Total cost: ~200 €</strong></p>
December 16th, 2013: Right in front of my window, where my bike is usually locked up, some asshat stole my handlebar. At least he/she had the decency of not cutting anything off, but taking their time to nicely remove my brakes and gear levers without damaging anything. It still took me a while to fix this, seeing how winter came. And I had bought the wrong handlebars as a replacement as well. But I finally fixed it... on April 16th.
Total cost: ~30 €</strong></p>
April 21st, 2014: I was able to ride my bike to university once. ONCE! Just once, before wanting to do the same again today. But no, my rear gear shift was completely missing and the chain was cut. This is just perfect. The bike was again locked up right outside my window, but I noticed nothing. I love the people around here...
Total cost this time: 200 €... Well crap</strong></p>
Update January 2015: One more theft in the meantime and brakes missing tonight. Both times from inside the locked bicycle room in my basement. Yay (┛ò__ó)┛彡┻━┻</p>


Valentina Kalashnikova - Last Dangerous Racoons
2013-11-07T20:53:48+02:00
Just got back from an awesome gig from a small local band a friend of mine plays in. They're called the Last Dangerous Racoons</strong> and this title of theirs is definitely worth a listen!</p>
</iframe>
Also check out their site</a> and bandcamp</a> if you're interested.</p>


Launching Alfred with Caps Lock on OS X
2013-11-05T20:50:33+02:00
In great contrast to Alfred</a> being one of those apps I love more than anything on OS X, the caps lock key is something utterly useless nowadays (or ever for that matter). And if you do happen to find yourself in an argument on the internet, even Homer Simpson agrees</a> that you put a lot more weight into your statement if you take your time to press the shift key. The already mentioned Alfred however is so immensely useful, that even two keys for its hotkey (the default alt</code> + space</code>) is too much. So why not combine the two and have a dedicated launch everything and search for stuff anywhere</em> key on your keyboard?</p>
So let's go ahead and set that up.</p>
Step 1 - Install Seil</h3>
The very cool Takayama Fumihiko (@tekezo</a>) wrote a great little tool dedicated to changing the behavior of the caps lock key (and some others for that matter) on Macs. Check out his site and download it</a>. And yes, this app works just fine with OS X 10.9 Mavericks and should also already support 10.10 Yosemite. Note: Before a few versions ago Seil was known as PCKeyboardHack.</p>
Step 2 - Getting the relevant key code</h3>
You could waste some time looking up the key code for the caps lock key, or you could download this nifty little app</a> to check it quickly.</p>
For me it was 103</strong>, but I don't want to guarantee that it'll be the same for you.</p>
Step 3 - Mapping the functionality</h3>
Unfortunately the caps lock key is a bit special. It isn't really registered by the system as a normal key like pretty much anything else, so we're going to have to map it to something. The F-keys on your keyboard are pretty useful for that, so just choose one of those, as long as you're not using it for anything else. It doesn't matter if it's a media key, if no function on your machine is set to happen when you press fn</code> + FX</code> (I'm using F11</code>), this would work.</p>
If you're not sure about this, check your System Preferences > Keyboard > Keyboard Shortcuts. Any functionality would be listed there.</p>
Open Key Codes, hold fn</code> if necessary and press your key. Aside from all the other information that should now be displayed, remember the key code.</p>
Now open up PCKeyboardHack, check the Change Caps Lock</em> option and set it to the key code we just looked up.</p>
Step 4 - Alfred</h3>
All that's left is changing Alfred's preferences. In the General tab, you'll see the Alfred Hotkey option. Set this to the F-key you chose earlier, remember to hold fn</code> if you're on an Apple keyboard.</p>
Step 5 - Disable caps lock</h3>
This step really isn't necessary for this to already be working, try it out!</p>
Something that seemed to be bothering me, is that Macs have a built-in feature to protect you from accidentally activating caps lock in every day use. This is a short delay when activating it (not deactivating, just activating), so when you press the key fast enough, nothing will happen. The only way to get around this is disabling caps lock itself, but that's not really a problem since we're not using it for its actual function anyways.</p>
The option for this is in the System Preferences > Keyboard > Modifier Keys. Set caps lock to No Action</em> here. That should do the trick. And now have fun!</p>
By the way:
the famous CR-48 Chromebooks</a> also had a dedicated search key instead of caps lock. I was jealous from the start, but this fixed it :)</p>

kilko.de - original posts

Importing CSV data into SQLite

Youtube RSS Feeds

GPTDash

Rotate videos

Keep subtitles while transcoding

Create video from image and audio

Concatenate videos

Change video container

Decoding Unknown Data with Codable

Simulating a scan

Server Setup with traefik and docker-compose

Huginn</h2> Huginn is slightly more complex since we're going to need two services. The application itself and a database.</p>

Paperless

Chat Statistics

Docker Swift Runtime

Reverse Engineering iOS Apps

Downloading older iOS app versions with iTunes

Keeping Static Images out of your GitHub Repo

Akronymisierbar

Automatically Increment Your Xcode Project's Build Number

Writing Custom Alfred Worklows

Using a Helper Library</h2> You'll make your life a lot easier using one of the plentiful alfred-workflow helper libraries out there, surely also for your language of choice.</p>

WWDC 16

On Quitting Facebook

WWDC 16 Scholarship

Cheap DynDNS Alternative

Firewatch

Black Mirror

32c3

HeartBattery

ParkenDD

Migrating to kilian.io

Pycharm and Java 8

Simple Robot

Installing OS X applications through Homebrew

This is getting ridiculous

Valentina Kalashnikova - Last Dangerous Racoons

Launching Alfred with Caps Lock on OS X