As this year's Congress design relies heavily on the Kario Duplex Var main font, we needed a rendering engine that could take full advantage of all the font's typographic features while enabling the relatively straightforward creation of images.

One of the initial tasks was to generate intros and outros for the conference recordings. Early drafts took a wild tour through all the shifting weights, zooms, and context-aware ligatures on offer. The first experiments with PIL and HarfBuzz produced discouraging results; for instance, the kerning broke hopelessly between animation phases. Although the Drawbot framework allowed for some nice static image generation features that made full use of all the font's 'easter eggs', it was not ideal for creating a stable animation, either.

However, there is another widely deployed and tested font rendering engine around: Your browser comes with a powerful engine that can dynamically produce high-quality animations using simple CSS rules, ready to be adopted and adjusted by even less experienced users. You can see its output in action every day.

Sooo, you want to know how I got it to render me an animation like this:

The first experiments were very promising, involving trivial animation statements such as

p#anim {
  animation: font_wave 3s ease-in-out 0s infinite alternate both;
}

over

@keyframes font_wave {
  from { font-weight: 10; }
  to { font-weight: 100; }
}

one can already prototype substantial in-browser animations of meandering states. So far, so good. However, recording these animations opened a can of worms. Asking the video crew to take dozens of screen recordings of their browser would probably make them reach for their batons. To prevent that, I took a deep dive down the rabbit hole of browser instrumentation, so you don't have to.

In terms of remotely controlling a browser, there are essentially only two serious protocols: the Firefox one and the Chrome DevTools Protocol. Only the CDP allows for screen casting. Since Chromium is available on virtually any platform imaginable, I just went with it.

The protocol looks quite reasonable at first. You launch your browser from the command line with

chromium-browser --remote-debugging-port=9222

or for our Apple users:

/Applications/Chromium.app/Contents/MacOS/Chromium --remote-debugging-port=9222

and then get yourself a list of more or less active control sockets like this:

import urllib.request
import json

CHROMIUM_REMOTE = "http://localhost:9222"
with urllib.request.urlopen(CHROMIUM_REMOTE + "/json") as resp:
    targets = json.load(resp)
    ws_url = targets[0]["webSocketDebuggerUrl"]
    print("Bootstrapping using ws_url: " + ws_url)

yields a happy little

Bootstrapping using ws_url: ws://localhost:9222/devtools/page/8095B17147D317CA8D55BA7FA99CA9A2

So far, so good.

It is of utmost the importance to understand that this first debugger URL is tied to a so called target, which may or may not be useful for remote control. This means that the target could represent a tab that has already been closed, e.g. with your Chromium settings. Therefore you need to create a new target that you have complete control over. Since you got yourself a WebSocket endpoint list that allows for bootstrapping, you can create a new target and attach to it to get a new session ID. From then on, use that session ID over the bootstrap websocket.

This process is not completely straightforward, is poorly documented and took me quite a while to understand, so feel free to use these snippets.:

import asyncio
import time, subprocess, json, base64, sys
import websockets
import urllib.request

CHROMIUM_REMOTE = "http://localhost:9222"
TARGET_URL = "https://erdgeist.org/39C3/font/index2.html"
VIEWPORT_WIDTH = 1920
VIEWPORT_HEIGHT = 1080
VIDEO_LENGTH_SEC = 5

async def main():
    # Discover the first available target for bootstrapping
    with urllib.request.urlopen(CHROMIUM_REMOTE + "/json") as resp:
        targets = json.load(resp)
    ws_url = targets[0]["webSocketDebuggerUrl"]
    print("Bootstrapping using ws_url: " + ws_url)

    async with websockets.connect(ws_url) as control_sock:
        msg_id = 0
        session_id = 0

        async def wait_for_id(expected):
            while True:
                msg = json.loads(await control_sock.recv())
                if msg.get("id") == expected:
                    return msg

        async def ws_send(method, params=None, in_session=True):
            nonlocal msg_id
            nonlocal session_id
            msg_id += 1
            cmd = {"id": msg_id, "method": method }
            if params:
                cmd["params"] = params
            if in_session:
                cmd["sessionId"] = session_id
            print("Sending " + json.dumps(cmd))
            await control_sock.send(json.dumps(cmd))
            return await wait_for_id(msg_id)

        create_resp = await ws_send("Target.createTarget", params = {"url": TARGET_URL}, in_session = False)
        target_id = create_resp["result"]["targetId"]

        attach_resp = await ws_send("Target.attachToTarget", params = {"targetId": target_id, "flatten": True}, in_session = False)
        session_id = attach_resp["result"]["sessionId"]
        print("target created and attached, session:", session_id)

This yields a

Sending {"id": 1, "method": "Target.createTarget", "params": {"url": "https://erdgeist.org/39C3/font/index3.html"}}
Sending {"id": 2, "method": "Target.attachToTarget", "params": {"targetId": "13A7AC88BB49C1E22A2AABA536375E77", "flatten": true}}
target created and attached, session: 9E73BE323AD10D72BB8A1BF7E7120ED9

and from then on, using the session_id for the new target, we can use the initial control socket to instrument our new tab.

Next, we need to do some housekeeping. First, we need to enable the page and set the dimensions of the viewport so that our screen recording is the correct size. We also need to be notified when the page has loaded all the necessary assets and rendered the firstMeaningfulPaint, so that we can start recording. This is why we enable the page's lifecycle events.

# Enable page, lifecycle events and set viewport dimension
await ws_send("Page.enable")
await ws_send("Page.setLifecycleEventsEnabled", {"enabled": True})

await ws_send("Page.setDeviceMetricsOverride", {
    "width": VIEWPORT_WIDTH,
    "height": VIEWPORT_HEIGHT,
    "deviceScaleFactor": 0,
    "mobile": False
})

Now, we just need to wait for the first paint event

while True:
    msg = json.loads(await control_sock.recv())
    if msg.get("method") == "Page.lifecycleEvent" and msg["params"]["name"] in ("firstMeaningfulPaintCandidate", "firstMeaningfulPaint"):
        break

and we're off to the races. The plan is simple: We want to start a screen cast with the given viewport width and height. In order to render high-quality, uncompressed animations, we will select a quality setting of 100 and the PNG format. There are two important things to note here: Firstly, the screencast is sent via your control socket as a series of screencastFrame messages, each containing some metadata and the base64-encoded payload. You must acknowledge each frame before the browser sends the next one. This is why we immediately acknowledge the frame before serialising it. Secondly, counterintuitively, the sessionId that needs to be sent with the frame ack is not your session's sessionId, but a new virtual sessionId generated for the screencast. This usually starts with 1 and is presented in the frame's metadata dictionary. In your ack message, it needs to go into the parameters dict, not the command dict, which will still require the session's sessionId.

To avoid blocking the backend for later frames, we defer heavy tasks such as re-encoding to MP4 and simply dump the stream to a JSONL file:

with open("temp_out.jsonl", "w") as f:

    # Start screencast
    await ws_send("Page.startScreencast", {
        "format": "png",
        "quality": 100,
        "maxWidth": VIEWPORT_WIDTH,
        "maxHeight": VIEWPORT_HEIGHT,
        "everyNthFrame": 1
    })

    start_time = time.time()
    while time.time() - start_time < 15:
        msg = json.loads(await control_sock.recv())

        if msg.get("method") == "Page.screencastFrame":
            params = msg["params"]

            # Fast-track acknowledgment (before file I/O)
            # Note: sessionId is for the screencast
            await ws_send("Page.screencastFrameAck", {"sessionId": params["sessionId"]})

            # Dump base64 frame string + timestamp
            record = {
                "timestamp": params["metadata"]["timestamp"],
                "data": params["data"]
            }
            f.write(json.dumps(record) + "\n")
            f.flush()
        else:
            print("Received " + json.dumps(msg))

Once we have finished, we stop the screencast, detach and close the target, i.e. browser tab.

# Stop screencast and close gracefully
await ws_send("Page.stopScreencast")
print("Stopped recording after", VIDEO_LENGTH_SEC, "seconds")

await ws_send({"method": "Target.detachFromTarget", "params": {"sessionId": session_id}})
await ws_send({"method": "Target.closeTarget", "params": {"targetId": target_id}})

All that's left to do is pipe the result through ffmpeg, to generate a nice and pristine mp4. I'm sure, you've installed ffmpeg by now.

ffmpeg = subprocess.Popen([
        "ffmpeg",
        "-y",                       # overwrite
        "-f", "image2pipe",         # stream of images
        "-vcodec", "png",           # input format
        "-r", str(60),              # assume 60 fps timing
        "-i", "-",                  # stdin
        "-c:v", "libx264",
        "-pix_fmt", "yuv420p",
        "out.mp4"
    ], stdin=subprocess.PIPE)

with open("temp_out.jsonl") as f:
    for line in f:
        rec = json.loads(line)
        ffmpeg.stdin.write(base64.b64decode(rec["data"]))

ffmpeg.stdin.close()
ffmpeg.wait()

Remember to actually execute main():

asyncio.run(main())

You should have a screen recording saved as out.mp4. You can find the complete source file here. The video should look something like the one at the top.

Ideally, we would just call it day and stitch together all the videos, but alas, despite our plan to record high-quality video at 60 fps, the Chromium gods had their own ideas about how often and when to render frames. Even more frustratingly, if the browser detects that there are no visible changes to the layout — for example, at the beginning or end of ease-in-out animations — it simply refuses to repaint and emit screencastFrame s.

Depending on the monitor or screen on which the browser was launched on, and the complexity of the scene due to be rendered, you will see frame rates all over the place. Although the metadata field in each of those Page.screencastFrame messages contains a precise enough timestamp to allow ffmpeg to re-create a better synchronised movie using a concat script generated in real time, we're entering a realm where we would need to generate interpolated in-between frames to achieve this. For most people, the current behaviour is sufficient.

However, I would like to use the browser's font rendering engine with a precise frame rate, even if that means abandoning the comforting guard rails of CSS animations. So let's look into that, shall we?

First I need to get rid of the annoying synchronisation of the browser's render cycles with the vsync and the browser opening and closing browser tabs on my desktop. From now on, we'll just launch the browser in a headless mode and instruct it not to limit its frame rate:

chromium-browser --headless=new --disable-gpu-vsync --disable-frame-rate-limit --remote-debugging-port=9222 --new-window about:blank

Much better! Now that the browser is no longer responsible for synchronisation, it is our job to manually cycle through all the animation steps ourselves. The idea is to have the website set up its animation once and then we single step through all states individually, taking a screenshot for each animation phase. Sure enough, calling and inspecting JavaScript Runtime functions and values is quite easy with the Runtime.evaluate() and Runtime.callFunctionOn() methods, respectively. To use these inside the site's scope, we need to enable the Runtime for the page once:

# Enable Runtime for access to JavaScript calls, Page and navigate to the target URL
await ws_send("Runtime.enable")
await ws_send("Page.enable")
await ws_send("Page.reload")

The Runtime.callFunctionOn() method requires an objectId to be called on. Obtaining one is more complicated than it has any right to be, but you can use JavaScript Runtime.evaluate() the window's objectId for you:

# Get window's objectId
resp = await ws_send("Runtime.evaluate", { "expression": "window", "objectGroup": "page", "returnByValue": False })
window_id = resp["result"]["result"]["objectId"]

This can then be passed to Runtime.callFunctionOn() as follows:

await ws_send("Runtime.callFunctionOn", params = {
    "objectId": window_id,
    "functionDeclaration": "function(config) { setContent(config); }",
    "arguments": [ { "value": {
        "title": "Your presentation's title",
        "fps": FRAME_RATE
    } } ]
});

The corresponding setContent function in the HTML should look like this:

function isEmojiOnly(str) {
  const stringToTest = str.replace(/ /g,'');
  const emojiRegex = /^(?:(?:\p{RI}\p{RI}|\p{Emoji}(?:\p{Emoji_Modifier}|\u{FE0F}\u{20E3}?|[\u{E0020}-\u{E007E}]+\u{E007F})?(?:\u{200D}\p{Emoji}(?:\p{Emoji_Modifier}|\u{FE0F}\u{20E3}?|[\u{E0020}-\u{E007E}]+\u{E007F})?)*)|[\u{1f900}-\u{1f9ff}\u{2600}-\u{26ff}\u{2700}-\u{27bf}])+$/u;
  return emojiRegex.test(stringToTest) && Number.isNaN(Number(stringToTest));
}

window.setContent = async function (content) {
  let title = document.querySelector('#title p');
  title.textContent = '';
  var offset = 0;
  for (let i = 0; i < content.title.length; i++) {
    let span = document.createElement('span');
    span.textContent = content.title.charAt(i);
    if (isEmojiOnly(span.textContent)) {
      span.classList.add('is-emoji');
    } else {
      span.setAttribute('anim-off', offset);
      offset += 1;
    }
    title.appendChild(span);
  }
  window.fps = content.fps ?? 60;
  window.content_set = true;
  console.log("seting content to ", content.title);
}

Please note that in order to retrieve the console.log output, you must to listen out for the Runtime.consoleAPICalled event.

Now that we no longer have any real-time requirements (remember that we now control when the new frame is rendered!), we can drop the intermediate JSONL containing the raw frame PNG and pipe all the images directly through FFmpeg like this:

ffmpeg = subprocess.Popen([
    "ffmpeg",
    "-y",
    "-f", "image2pipe", "-framerate", str(args.frame_rate),
    "-i", "-", "-pix_fmt", "yuv420p", "-f", "mp4", args.movie_name
], stdin=subprocess.PIPE)

for i in range(args.frame_count):
    await ws_send( "Runtime.evaluate", params = { "expression": "renderFrame()", "awaitPromise": True })

    resp = await ws_send( "Page.captureScreenshot", params = { "format": "png" })

    png_b64 = resp["result"]["data"]
    png_bytes = base64.b64decode(png_b64)
    ffmpeg.stdin.write(png_bytes)

we perform the detaching and closing as before, wait for ffmpeg to settle … and then we're finished. Just add a tiny argument parser like this one:

parser = argparse.ArgumentParser(description='Render chrome anim.')
parser.add_argument('--chrome-remote', default=CHROME_REMOTE, type=str)
parser.add_argument('--movie-name', default=VIDEO_OUT_PATH, type=str)
parser.add_argument('--frame-rate', default=FRAMERATE, type=int)
parser.add_argument('--frame-count', default=FRAMECOUNT, type=int)
parser.add_argument('--frame-width', default=VIEWPORT_WIDTH, type=int)
parser.add_argument('--frame-height', default=VIEWPORT_HEIGHT, type=int)

parser.add_argument('--url', default='file://./index.html', type=str)

args = parser.parse_args()

asyncio.run(main(args))

The recording part of our new little setup is complete. The only thing left to implement is the renderFrame() function in our JavaScript world which prepares the scene for the next screenshot. As we now have to do the animations manually, I first lifted the easing functions right from easing.net, and chose easeInOutQuad for my font weight animation:

window.renderFrame = async function(from_CDP = true) {
  let fps = window.fps ?? 60.0;

  let main_anim_duration = 7.0 * fps;
  let main_anim_period = 2.0 * fps;

  /* Animate main scene font weight */
  let para = document.querySelector('#anim');
  let frame = window.frame ?? 0;
  if (frame < main_anim_duration) {
    let cycle = (frame % main_anim_period) / main_anim_period; /* Runs 0..1*/
    let normalized = 2.0 * cycle - 1.0; /* Runs -1..+1*/
    let shifted = 1.0 - Math.abs(normalized); /* Runs 0..1..0 */

    let easing = easeInOutQuad(shifted);
    let weight = 10 + easing * 90;
    para.style.fontWeight = weight;
  } else
    para.style.fontWeight = 100;

  window.frame = frame + 1;

  // first rAF: flush style & layout
  await new Promise(requestAnimationFrame);
  // second rAF: ensures paint has happened
  await new Promise(requestAnimationFrame);
}

Note that we're synchronising with the rAF method twice to ensure that a new render method is triggered and that it was not already triggered before we set the new styles. The "awaitPromise": True when calling Runtime.evaluate on our renderFrame method ensures that both painting Promises have been fulfilled and that the page is indeed ready for a snapshot.

Stitching all these snippets together should produce a working scene renderer, like the one in this demo, which can produce videos like this one.

I'm not much of a web dev, but I embrace the occasional quick and dirty Flask-SQLAlchemy hack to scratch my itch and when forced, I try to resort to solve my problems using vanilla.js. So when I committed to freshen up a certain site to make it presentable until the imminent rewrite, one of the loudest requests was to implement a dark mode. So I dug down a rabbit hole to find out how to do that properly, using only minimally invasive tools. Here's what I learned, so you don't have to sit through meandering youtube videos.

The first and simplest thing to do is to tell the browser that your site actually supports color-schemes by applying the appropriate style to the body of your document:

body {
  color-scheme: light dark;
}

That's it. The browser will now select a dark mode for your site, if the user has configured it system-wide or browser-wide. Thanks for listening, don't forget to like and subscribe.

But … wait! My site looks ugly now. In dark mode, all the white and grey background colours I use still work only on bright backgrounds and on some pages I even still see background-color white.

body {
  background-color: Canvas;
  color: color-mix(in srgb, CanvasText, #808080 25%);
}

@media (prefers-color-scheme: light) {
  a, a:visited {
    color: blue;
  }
}

@media (prefers-color-scheme: dark) {
  a, a:visited {
    color: yellow;
  }
}

@media (prefers-color-scheme: dark) {
  #header img {
    filter: invert(50%);
  }
}

body.some-class {
  color-scheme: light;
}

<input id="override-mode" type="checkbox" aria-label="Switch between dark and light mode">
<label for="override-mode"><span class="hidden">lights</span></label>

@media (prefers-color-scheme: light) {
  body:has(#override-mode:checked) {
    color-scheme: dark;
  }
}

@media (prefers-color-scheme: dark) {
  body:has(#override-mode:checked) {
    color-scheme: light;
  }
}

@media (prefers-color-scheme: dark) {
  body:not(:has(#override-mode:checked)) #header img {
    filter: invert(50%);
  }
}

.hidden,
input#override-mode[type="checkbox"] {
  display: none;
}

@media (prefers-color-scheme: light) {
  body:has(#override-mode:checked) {
    color-scheme: dark;
  }
  #override-mode + label[for=override-mode]:before { content: '🌙'; }
  #override-mode:checked + label[for=override-mode]:before { content: '☀️'; }
}

@media (prefers-color-scheme: dark) {
  body:has(#override-mode:checked) {
      color-scheme: light;
  }
  #override-mode + label[for=override-mode]:before { content: '☀️'; }
  #override-mode:checked + label[for=override-mode]:before { content: '🌙'; }
}

label[for=override-mode] {
  font-size: 0.8em;
  user-select: none;
  filter: grayscale(1) contrast(10%);
}

<head>
  <script>
    (function() { document.addEventListener("DOMContentLoaded", function() {
      if (localStorage.getItem('override-prefers-color-scheme', false))
        document.getElementById("override-mode").checked = true;
      });
    })();
  </script>
</head>

$(document).ready(function(){
  document.getElementById("override-mode").addEventListener("change", () => {
    if (document.getElementById("override-mode").checked)
      localStorage.setItem("override-prefers-color-scheme", 1);
    else
      localStorage.removeItem("override-prefers-color-scheme");
  });
});

Over the years I've had to make a lot of choices, about what editor, programming language, frameworks and whole projects to pick to get stuff done. Think coding for university, setting up projects for work and customers, writing open source software and maintaining services for the community.

While some of the decisions were no-brainers, e.g. when the company I worked for has had already settled on a framework or there was only a single tool available, most of the times there was quite an array of options to chose from and picking the right one required some effort – and hindsight I simply didn't have at the time.

As all older people do, I assume that me writing down my lessons learned will prevent you, dear reader, from making your own mistakes. So without further ado, I introduce my 7 points of how to spot software projects that may or may not work for you.

1. Define your breaking points!

Remember: Sometimes it's okay to just say no completely. You do not have to settle for the least ugly option, especially when doing open source work. You should decide in advance how much energy your project is worth. You may then decide if it's smarter to abandon your plans or to bite the bullet and chose a sub-optimal dependency, or even fork or set up a new project to solve the unsolved.

At your work place, you might put up with much worse options than with projects you want to do in your spare time, but maybe you can take this list and convince your boss or co-workers to re-evaluate decisions.

2. How much does the project know and communicate about prior art, best practises and how they fit in there?

Did the project authors and maintainers spend the effort of building platform ports or are you required to follow a "Best viewed with Internet Explorer 6 in 1024 x 768" approach and force you to deploy precise replicas of their setups?

red flags:

• curl | bash,
• bashisms in Makefile or shell scripts,
• "Windows filenames" (build breaks if filesystem is case sensitive),
• temp files or editor backup files in distribution,
• hard-coded credentials or certificates,
• project builds only in Docker / github CI pipeline,
• source code treated as second-class installation option (they really want you to install binary packages),
• dependencies on tools or libraries in versions other than current stable release.

green flags:

• packages for more than one platform,
• build enables all compiler warnings and none show up during regular build,
• build system comes prepared for cross-compilation,
• project has open bug tracker,
• bug tracker shows that bugs are attended to and not closed on a whim,
• README clearly states security contact for when you find a security bug.

Are the project's devs and contributors active on other projects, maybe even some you've heard of?

Does the user and admin documentation hint at the authors following best practices? This is important because, for example as an admin, you don't want to be stuck studying the complete project and their dependencies just for trouble shooting a single problem.

Are the project's maintainers aware of trade-offs and short comings of their project?

red flag:

• The project page is full of marketing speech and a liberal use of "awesome" words.

green flag:

• Embracing criticism. You can only be a true fan of a project if you have at least one hour worth of rant about the warts-and-all.

3. Do you like the project's documentation?

Does the project's documentation cover the basics with some handy primers and how to grow from using a small feature set to the whole API?

Will the first google hit for a medium complexity keyword from the project – be it an API call, a config keyword or keyboard short cut – be somewhere at the project's page or on Stack Overflow?

Does the project come with some good opinionated defaults along with their respective rationales?

Are the defaults there because they are useful or for backwards compatibility?

Do you have to manually turn on vital security aspects?

Are obscure knobs documented? Older projects usually have some special functions or knobs for special cases that probably won't apply to you. The documentation should make clear which options are for obscure special cases so you don't get lost in the details when looking for a specific thing.

Do they thoroughly cover how to maintain the projects or do all the guides stop right after you installed the project? Which leads us to …

4. How much regular attention does the project require?

Good tools require cleaning and maintainance – but once you spend all your time just on your tools, you're not getting work done.

Does the project clearly understand and communicate what dependencies they bring and how to keep those up to date?

Are those dependencies well balanced? Is the same true for their recursive dependencies (this includes the programming languages chosen).

As a more specific example, is the project written in a language with a clear and complete runtime for the basics? Think libc vs. leftpad, python's batteries included approach, etc.

A good sign is a few dependencies with a guaranteed stable API.

Once you understand the dependency tree, is there another option with fewer deps? IOW: Do you need all the things provided by the project at hand, or is there a more specific tool for your problem?

Given how much time you can realistically spend on a single dependency: Can the project and its stack cope with routine maintainance intervals of one year? Does the project give guarantees not to break config or user data on updates?

Does the project have a policy and a schedule for updates vs upgrades vs security patches? Are they free without a subscription?

If the user can't chose maintainance time (e.g. on security updates), does the project guarantee that you will not be forced to upgrade to breaking changes?

How quickly are dependencies deprecated? Are you required to re-work basic functionality within less than a year?

5. Is the project there to stay?

What is the project's head count?

Is the community's size in a healthy proportion to the project's complexity?

What kind of contributors and users does the project attract? How's the tone in associated forums? Is that a good sign for you?

Where's the project hosted at? Does it run some own infrastructure or will the dependency break once you or your customers are in a sanctioned region?

Has project ownership changed hands? More than once?

6. … and if not do they help you to move on?

If the project provides migration helpers, do they only point in one direction?

Can you dump payloads, meta data and config information in a structured format that helps you inspecting and importing it elsewhere later? From my experience it is best, if the project did anticipate its obsolescence and provide these functions right from the start.

Does the project's config language require knowledge about some plumbing that you should not need to care about?

Can you see a clear path how to use a competing project or it's API should you reconsider or are you stuck to the point of requiring a rewrite or complete re-start of your project?

7. What's the extra baggage YOU leave?

If you need to hand over the project due to unforeseeable circumstances, is it easy to find replacement for you, your config, private forks or tweaks?

Does your choice of programming language or framework leave your colleagues or peers with further technical debt and fewer good options? Sometimes it's better to go with a mainstream choice so that more or more affordable peers can contribute later.

Would your own project tick all the above points to your own satisfaction?

Gestern erreichte mich eine freundliche E-Mail eines Juristen, der in der Legal-Tech-Szene aktiv ist. Darin erklärte er, Teil eines Teams zu sein, das im Februar überraschend mit seinem Projekt einen Hackathon gewonnen hätte. Das dort entstandene Tool "Dickstinction" wurde am Tag der E-Mail bei Netzpolitik behandelt. In der Folge wurden ihm Hinweise zugetragen, nach denen eine gewisse Ähnlichkeit mit dem Abmahnbeantworter des CCC unverkennbar ist. Der wird in dem Artikel bei netzpolitik.org erwähnt, allerdings fälschlicherweise in eine Reihe gestellt mit kommerziellen Projekten. Der Abmahnbeantworter hat aber kein Geschäftsmodell, sondern ist ein kostenloses Angebot an Betroffene von unberechtigten Abmahnungen.

In der E-Mail entschuldigte sich der Jurist freundlich für die ungefragte Übernahme des Konzepts und bot an, nachträglich einen Hinweis auf den Ideengeber (also uns) auf die Webseite von Dickstinction zu schreiben und unser Projekt fortan in Interviews zu erwähnen, da sich das Team ja stark an der Vorlage des Abmahnbeantworters orientiert habe. Genaues wisse er nicht, da er kein Programmierer sei, aber er wolle auf jeden Fall bescheidgeben und nach meiner Meinung fragen. Soweit total korrekt.

Der Abmahnbeantworter wurde vor vier Jahren – unter juristischer Beratung von RAin Beata Hubrig und durch Umsetzen des Interface- und Usability-Designs von Malik Aziz – nach mehreren Monaten harten Lernens und Testens entwickelt. Ich bin tatsächlich kein Webprogrammierer, sondern eher in C/C++/Assembler zuhause, weswegen der Lernprozess zeitintensiv war. Daher war ich natürlich erstmal interessiert, welche Aspekte des Abmahnbeantworters wohl übernommen worden waren, auch um eventuell selber Ideen für Verbesserungen aufzuschnappen – Konkurrenz belebt ja das Geschäft. Eine kurze Inspektion der Web-Resourcen des Dickstinction-Projekts hat mich dann doch ehrlich erschüttert: Man muss schlicht nur deren main.js gegen unsere abmahn.js halten oder die Strukturen der jeweiligen HTML-Seiten oder das CSS vergleichen, um in Abgründe zu sehen, derer sich wohl einzig von Guttenberg nicht schämen würde.

In der FAQ von Dickstinction wird neben einem Vorstellungsvideo die Genese des Dickstinction-Projekts kurz umrissen:

"Dickstinction haben wir im Februar 2020 im Rahmen des Berlin Legal Hackathon 2020 in weniger als 24h programmiert und damit den ersten Preis gewonnen."

Dazu kann ich nur sagen: Nein, habt ihr nicht! Programmieren bedeutet eine recht langwierige Arbeit mit Nachdenken, Selbstkorrektur, manchmal ein bisschen Schweiß. Kopieren ist hingegen schnell erledigt.

Während mir Euer Projekt-Konzept wirklich schwer am Herzen liegt und es mir schon jetzt die Tränen in die Augen treibt, sollte dieser Rant hier dem Projekt schaden, fühlt es sich unendlich mies an, wenn sich (laut der E-Mail zwei) Entwickler für die Präsentation eines dreisten Plagiats beklatschen lassen, in dessen Original ich ehrenamtlich viel Herzblut, monatelange Arbeit und Koordinationsaufwand gesteckt habe. Daher weiß ich übrigens auch, dass man sowas nicht mal eben in einem 24-Stunden-Hackathon runterschreibt. Ich weiß zwar nicht, wer aus der Liste in der FAQ genau die Programmierer sind, die sich an meinem Code bedient haben, aber ich sehe hier erstmal mehrere Probleme, die das Dickstinction-Projekt nun intern klären muss.

Das alles wirft einen schweren Ballast auf meinen Eifer und mein ehrenamtliches Engagement, vor allem, weil vor drei Jahren bereits ein anderes meiner Open-Source-Projekte als Voll-Plagiat neu-veröffentlicht und vom Plagiator auch noch öffentlich auf allen Kanälen beworben wurde: Das hatte ich damals in einem Blog-Post zu ezjail vs qjail niedergeschrieben.

Ich habe dem Verfasser der E-Mail geantwortet und meine Gedanken dargelegt.

Zuerst: Ich persönlich bin eigentlich kein Web-Programmierer, daher macht es mir eher Angst, wenn mein Web-Code von Leuten verwendet wird, die von den intrinsischen Annahmen über dessen Verwendung wenig Ahnung haben. Es ist eben keine Software-Bibliothek, was sich auch in der eher unterdurchschnittlichen Kommentierung und Dokumentation niederschlägt. Weil es eben nicht zum Wiederverwenden gedacht war, habe ich mir auch keine Gedanken um eine Lizenz gemacht. Ich bin schlicht nicht davon ausgegangen, dass sich jemand daran "orientiert" oder es eben komplett kopiert.

Das bringt mich nun in eine blöde Lage. Normalerweise veröffentliche ich meine Open-Source-Projekte (https://erdgeist.org so der Abschnitt links) unter der Beerware-Lizenz https://erdgeist.org/beerware.html, was grundsätzlich Public-Domain mit der Ausnahme Namensnennung ist. Am Projekt selber steht aus o. g. Gründen keine Lizenz dran, was grundsätzlich ja erstmal bedeutet, dass wir am Code volles Urheber- und Verwertungsrecht haben. Natürlich wollen wir das nicht hart geltend machen, aber … als Open-Source-Coder hat man quasi nicht viel außer Reputation, und es fühlt sich nicht cool an.

Was mich noch mehr bewegt, IHR müsst ja erstmal irgendwie damit umgehen, dass ihr mit einem Plagiat Eurer beiden Entwickler einen ersten Platz bei einem Hackathon belegt habt. Das schmälert nicht die Leistung derer, die am Ende die Projekt-Idee entwickelt haben. Aber ich denke, für den Gewinn eines Hackathons sollten die Programmierer schon ein bisschen mehr vorzuweisen haben als "ich habe ein fremdes Projekt genommen, andere Farben rangemacht und meinen Namen drangeschrieben".

Es gibt außer sonst nur leichten optischen Änderungen übrigens eine nicht ganz unwichtige Abweichung zwischen dem Abmahnbeantworter und Dickstinction: Die gloriosen Hackathon-Gewinner haben sich immerhin die Zeit genommen, das Google-Tracking (firebase) zu integrieren. Ob das eine gute Idee ist, die Penisbilder-Informationen in die Vereinigten Staaten zu übermitteln, will ich nicht weiter kommentieren. Selbstverständlich findet beim Abmahnbeantworter keinerlei Tracking statt.

Ich werde rechtlich nicht gegen das Projekt vorgehen, sondern unterstütze die Intention weiterhin. Aber diese Art, für den billigen Ruhm beim Hackathon bei anderen Leuten zu klauen, darf nicht zum Standard werden. Deswegen kann ich auch nicht dazu schweigen, wenn ich derjenige bin, von dem dreist kopiert wurde. Ich denke sogar: Man darf dazu nicht schweigen, denn dann machen solche Leute einfach weiter wie bisher.

Und während in der E-Mail noch der Hinweis auf den nichtkommerziellen Hintergrund des Projekts kam:

Wie ihr sehen könnt, dient die nicht-kommerzielle Seite einem guten Zweck, weshalb wir uns über die Nutzungsmöglichkeit sehr freuen würden!

, deutet die Übergabe des Gewinnerschecks in Höhe von 2000 € darauf hin, dass sich die Projektbeteiligten das eine oder andere Spielzeug shoppen gehen konnten. Natürlich kommt es mir nicht darauf an, das Geld jetzt selber einzustreichen, aber ich habe so ein Bauchgefühl, wo es korrekterweise nicht hingehört. Und auch für die Zukunft würde ich mir wünschen, dass der Austausch mit Unternehmen für weitere Features den "nicht-kommerziellen" Hintergrund des Projekts nicht korrumpiert.

Im selben Interview finden sich auch besorgniserregende Informationshäppchen. Die verklausulierte Perspektive:

Rein rechtlich finden wir diesen aber besonders spannend, weil man sich auf elegante Weise den Möglichkeiten des Strafprozessrechts bedienen kann, um einen zivilrechtlichen Anspruch durchzusetzen.

bedeutet letztendlich nichts anderes, als auf dem automatisierten Generator ein eigenes kostenpflichtiges Abmahn-Modell zu begründen. Ein zuckersüßes Sahnehäubchen ins Gesicht unserer ursprünglichen Bemühungen, den Abmahnwahn einzudämmen.

Was die Mädels und Jungs bei Dickstinction jetzt draus machen, wird sich zeigen.

Update

Inzwischen habe ich von einem der Programmierer, Stefan B, eine E-Mail bekommen, in der er die Geschichte als kleines Versehen abtut und mich bittet, doch nachträglich die Engine als Open-Source-Projekt zu veröffentlichen und ihnen die Nutzung zu erlauben.

Was hältst du davon den Code der Seite unter einer Open-Source Lizenz zu veröffentlichen, sodass jeder diesen nutzten und weiterentwickeln kann?

In einer Welt des Kommerz einen nicht- oder antikommerziellen Kosmos zu pflegen, ist hart. Die Menschen, die sich in dieser besonderen Sphäre zusammenfinden, wie wir sie auf unseren CCC-Veranstaltungen seit Jahren hochhalten, kommen aus den unterschiedlichsten Schichten und leben im Rest des Jahres nicht im luftleeren Raum. Sie müssen sich ernähren, müssen wohnen und wollen gesellschaftliche Teilhabe auch an Ereignissen, bei denen sie nicht – wie bei Camp und Congress und viele der kleineren CCC-Veranstaltungen – bewusst subventioniert werden. Doch auf unseren Veranstaltungen müssen wir alle damit klarkommen, das Spannungsfeld von deutlichen Wohlstandsunterschieden und die Auswirkungen von Lebensentwürfen mit unterschiedlicher Zeitflexibilität hautnah mitzuerleben.

Wir sehen unsere Veranstaltungen als solidarisch organisierte Ereignisse, bei denen Teilnehmer mit mehr finanziellen Resourcen regelmäßig mehr geben – sei es direkt beim Solidar-Eintrittspreis oder beim großzügigeren Merch-Kauf – als Teilnehmer mit weniger flexiblen Möglichkeiten. Für besondere Härtefälle versuchen wir zudem seit Jahren, faire Möglichkeiten anzubieten, sich an den unvermeidlichen Kosten der Veranstaltung im Rahmen der eigenen finanziellen Kräfte zu beteiligen. Auch wenn sich hundert Euro pro Jahr erträglich anhören, gibt es genug Lebenskünstler und Hacker, für die dieser Zehner im Monat einen bedeutenden Einschnitt bedeutet.

Dass wir trotzdem mit einem konkurrenzlos fairen Eintritt von rund hundert Euro für vier Tage Konferenz hinkommen, liegt an der beeindruckenden, sich selbst organisierenden freiwilligen Arbeit der inzwischen tausenden Helfer. Und diese sind dazu natürlich nicht für jede beliebige Veranstaltung bereit, sondern spenden ihre Zeit und Energie einer Community, der sie gern angehören. Niemand mag es aber, ausgenutzt zu werden. Unser Experiment funktioniert nur deshalb so gut, weil wir seit Jahren offensiv vorleben, und auch sozial kontrollieren, dass dieses ehrenamtliche, unbezahlte Engagement vieler nicht von einzelnen anderen monetarisiert wird. Denn in dem Moment, wo Zweifel aufkommen, ob die Orga Entscheidungen trifft, um sich selber zu bereichern, oder wenn geduldet wird, dass sich jemand innerhalb der Veranstaltung oder am Namen bereichern möchte – da liegt ja schließlich buchstäblich das Geld auf der Straße – , bricht die einzigartige Kultur des nicht-kommerziellen Raums zusammen.

Nun ist es so, dass auch die Menge Freizeit, die ein Einzelner in sein Ehrenamt (und als solches sehen wir den Beitrag zu den C3) investieren kann, je nach Hintergrund schwankt. Alleine zu den Orga-Treffen aus der Bundesrepublik anzureisen, ist zeitlich und finanziell anstrengend und wird daher von uns gefördert. Einige Menschen werden von den Mechanismen der "hochflexiblen" Arbeitswelt täglich von 7-17 Uhr plus Anfahrt ausgelaugt, haben familiäre Verpflichtungen und können sich vielleicht nur an Wochenenden voll einbringen, andere hingegen haben hochspezialisierte Jobs, kommen mit moderatem Zeiteinsatz finanziell gut über die Runden und können daher mehr oder regelmäßiger Energie in unser gemeinsames Projekt stecken.

Und hier liegt die größte Gefahr für das Gerechtigkeitsempfinden: Wer seine Resourcen überschätzt (und das ist nicht als Vorwurf an die Freiwilligen zu verstehen) und sich in unserer Szene in einem Maße einbringt, wie es ihnen andere mit zeitflexibleren Umständen vorleben, kann schnell an die Grenzen seiner Möglichkeiten kommen. Ich habe es in meinem Umfeld mehrfach gesehen, dass sich gerade in Jahren mit Congress- und Camp-Vorbereitung Freunde Hals über Kopf in den Orgatrubel gestürzt haben statt erwerbszuarbeiten, um dann am Ende des Jahres überrascht auf ihren Kontoauszug zu starren. Mir selber ist es passiert, dass ich nach einem Campsommer mit den über's Jahr mental beiseitesortierten Steuerforderungen konfrontiert wurde und dem Vollzieher Dinge erklären musste.

Daher denke ich, dass die Szene einen offensiven Umgang mit Freunden braucht, die dabei sind, sich selbst zu verheizen. Es ist total cool, wenn sich jeder im Rahmen seiner Möglichkeiten zu 100 % einbringt – eventuell mit koordinierten und an anderer Stelle wieder aufgefangenen 110 %. Nicht cool ist, wenn wir als Community einige Teilnehmer erst nach einer Phase der Anstrengungen über ihrem Limit auflesen, wenn sie sich verzweifelt nach einem Lebensunterhalt oder gar einem Schuldenabbauplan umsehen müssen. Der naheliegendste – weil vordergründig gerechte – Weg ist natürlich, die Community mit Verweis auf die Ursachen der Klemme zu aktivieren und mit Crowdfunding oder einem Spendenhut das Schlimmste aufzufangen. Die Hilfsbereitschaft in der Community gibt dies meist auch her.

Problematisch sind hier aber zwei Dinge: Wenn aus einer kurzfristigen Hilfe in einer Notsituation ein Anspruch extrapoliert wird, landen wir ziemlich schnell bei der Diskussion, ab wann diese teils selbstverschuldeten Umstände keine Hilfe mehr rechtfertigen, oder anders, wie man schon im Vorfeld freiwillige Mithilfe am Projekt zurückweist, bei der abzusehen ist, dass sich der Teilnehmer in eine solche Abhängigkeit begibt.

Denn wenn die ersten anfangen, ihre Existenz – wenn auch teilweise – an den Erfolg der Community zu hängen, braucht es für die Sicherstellung ihrer Existenz Mittel. Und wenn es Mittel zu verteilen gibt, wird jeder seinen Beitrag mit dem Beitrag dieser anderen vergleichen – nicht mehr seine Möglichkeiten mit denen der anderen – und eine entsprechende Vergütung für sich einfordern. Es bräuchte plötzlich viel mehr Geld und ein striktes Controlling für die zu verteilenden Mittel. Und wenn Teilnehmer dieselben Aufgaben unbezahlt erledigen wie vergütete Mit-Teilnehmer, kommt die berechtigte Frage nach dem Warum auf. Die Folge davon ist, dass Teilnehmer anfangen, ihre Beteiligung zu überdenken und zurückzufahren.

Dieser dem Congress-Gedanken diametral stehende Gegenentwurf – eine Annäherung an so etwas wie reale Personalkosten – würde eine Spirale von zwangsweise darauffolgenden Eintrittspreis-Erhöhungen nach sich ziehen oder schlimmer noch: den Einmarsch von gezielter Werbung, was einem Ende der Unabhängigkeit und Glaubwürdigkeit des Kulturkreises gleichkäme. Bis heute zeichnet sich die ganze Veranstaltung durch eine erfrischende Freiheit von Werbemüll aus – und wir wollen das so behalten. Und an den Preisen deutlich zu drehen, würde wiederum einen Ausschluss von Schwächeren nach sich ziehen – für uns ebenso inakzeptabel.

Zweitens finde ich bedenklich, dass die Möglichkeiten, die Community zu aktivieren, stark von der Sichtbarkeit (oder Reichweite oder Vernetzung) des Betroffenen abhängt. Im Konkreten: Wenn ein Teilnehmer als Lagerverwalter im LOC nach dem Abbau vor dem Nichts steht, hat er eine viel kleinere Plattform als beispielsweise ich oder bestimmte Teams mit einer starken Außen- oder Innenwirkung (think Podcaster, c3nav, Heralde). Dieser privilegierten Position müssen sich die sichtbaren Helfer bewusst werden, bevor sie diese von uns allen hergestellte Reichweite benutzen, um einen gefühlt gerechtfertigten Ausgleich für ihre Arbeit zu fordern.

Und wir als Community müssen uns der Aufgabe stellen, offen über Selbstausbeutung zu sprechen, Mithilfe-Angebote kritisch nach der individuellen Nachhaltigkeit hinterfragen und im Zweifel zurückzuweisen.

TLS certificates, not so long ago still a gold mine for shady “trust” resellers, have become a commodity, since Let’s encrypt made it their mission to provide everyone with domain-validated certificates to secure their connections. There’s a plethora of useful tools to keep your certs up-to-date. I for my part favour the bash-only dehydrated and even wrote a tiny guide how to get it running on FreeBSD using privilege separation (i.e. not as root).

Now all was well and I deployed this everywhere until I stumbled over a project where users could create their own team-sites on demand, having their own subdomain. But because acme – the protocol behind Let’s encrypt – did not support wild card certs, I would (at least in theory) have created a different cert for each of these domains, or at least have their sub domain added to the SubjAltName list of the web server’s cert. Which is what I grudgingly did for a while: Identify the most active team sites and manually add them to the domain name list for my LE certs.

You can imagine how glad I was when I heard that acme v2 added support for wild card certs. Until I noticed that they require a new authentication method over DNS to provide them. What the hell were they smoking? In order to renew your wild card cert every 90 days, you would need to allow unattended updates to your name server from the server taking care of the renewals. To understand, what a stupid idea the is, look no further than at the proliferation of plugins of varying software quality now scripting DNS service updates for dehydrated.

In every remotely sane setup you would separate the services so that your web server wouldn’t need to know about its name server, let alone have access and credentials to update it. With the old acme http-01 protocol, the instance handling nearly every aspect of TLS anyway – in my case nginx – would be the only service involved, allowing for some neat separation: Only the .well-known directory would need to have a letsencrypt specific ownership.

A much less intrusive solution would have been to just require a static TXT record in your zone, stating that wild card certs are okay in principle (i.e. _acme.example.com TXT "wild card enable") and then have the acme server use the old http-01 mechanism to fetch challenge tokens from one or multiple random sub domains. This should be more than enough to proof that you control wild card dns.

However now we’re stuck with the less than optimal solution and I still needed a wild card cert. Since I do not directly control the name server, I needed to ask for a delegation. That meant that I would actually have to run a name server for this zone. On my web server. Great!

After shopping around for a while I’ve found tinydns, the authoritative name server from the djbdns bundle, to still be the least complicated server around. It sports its own very simple DNS record description language (that’s important, if you want to update and create it from simple shell scripts), is really, REALLY tiny and has an excellent security and performance track record. It basically pre-compiles every conceivable DNS response, stores it in an efficient constant single file database which can be atomically replaced while the server is running, meaning I didn’t have to meddle with permission to send signals to reload the zones.

Unfortunately, Dan Bernstein, tinydns’ author really likes you to run services the way he considers most convenient, using the daemon tools package sporting a steep learning curve. Since tinydns comes as a simple stand alone server, I just wrote a FreeBSD rc-script to start it as the FreeBSD gods have intended services to be started. Just place this file as /usr/local/etc/rc.d/tinydns, set execute (+x) permissions and enable it in rc.conf.

#!/bin/sh

#
# PROVIDES: tinydns
# REQUIRE: DAEMON cleanvar
# BEFORE: LOGIN
# KEYWORD: shutdown
#
# Add the following to /etc/rc.conf to enable this service:
#
# tinydns_enable="YES"
#
# tinydns_ip
# tinydns_root

. /etc/rc.subr

name=tinydns
rcvar=tinydns_enable
command=/usr/local/bin/tinydns

start_cmd=tinydns_start
pidfile=/var/run/tinydns

load_rc_config $name

: ${tinydns_enable:=no}
: ${tinydns_ip:=0.0.0.0}
: ${tinydns_root:=/etc/tinydns/root}

tinydns_start() {
    IP=${tinydns_ip} ROOT=${tinydns_root} UID=bind GID=bind ${command} >/dev/null 2>/dev/null &
    echo $! > ${pidfile}
}

run_rc_command "$1"

I placed my compiled zone file in /etc/tinydns/root/data.cdb, so the paths just work. My uncompiled zone file (i.e. source at /etc/tinydns/root/data) looks like this:

Zservice.example.com.:ns.service.example.com.:erdgeist@ccc.de.::86400:7200:604800:43200:43200
&service.example.com.::ns.service.example.com.:43200

+ns.service.example.com.:10.1.1.1:43200

@service.example.com.::mail.service.example.com.:50:43200
@*.service.example.com::mail.service.example.com.:50:43200

+service.example.com.:10.1.1.2:43200
+*.service.example.com.:10.1.1.2:43200

For AAAA records you might pre-compile an answer here or use Fefes tindydns IPv6 patches for a simpler syntax.

Once the file is there, you compile it using tinydns-data (within the /etc/tinydns/root/ directory. Yay!). Best is to also give it to your letsencrypt user right now.

cd /etc/tinydns/root
tinydns-data > data.cdb
chown -R letsencrypt /etc/tinydns/root

Finally, you need to add the actual code to your hooks. I just modified the file hook.sh in /usr/local/etc/dehydrated/ to read in the deploy_challenge() { function

printf "\'_acme-challenge.%s:%s:120\n" ${DOMAIN} ${TOKEN_VALUE} >> /etc/tinydns/root/data
cd /etc/tinydns/root/
tinydns-data > /etc/tinydns/root/data.cdb

and for later cleanup in the clean_challenge() { function I added

sed -E -i '' '/_acme-challenge/d' /etc/tinydns/root/data
cd /etc/tinydns/root/
tinydns-data > /etc/tinydns/root/data.cdb

After all is set and done, you need to change the default scheme to dns-01 in your dehydrated config (which is kind of silly, because all other domains on that nginx host require http-01 auth, but maybe there’ll be a patch to dehydrated to support multiple challenge types in the same config). I just changed the config line for CHALLENGETYPE line to read CHALLENGETYPE="dns-01" in my /usr/local/etc/dehydrated/config. I also enabled the HOOK=/usr/local/etc/dehydrated/hook.sh line.

Then you can just run

su letsencrypt
dehydrated -c

and enjoy your wild card certs.

Nachdem ich jetzt zwei Jahre mit meinem Elektroroller [1] quasi täglich [2] durch die Stadt gleite, ist es Zeit für eine Retrospektive. Ich habe lange überlegt, ob ich meine Erfahrungen mit meinem speziellen Modell so allgemeingültig zusammenfassen kann. Zudem bin ich kein erfahrener Produkttester und würde ungern unnötig Werbung oder Schmäh für einen Anbieter verbreiten. Da ich aber wieder an jeder zweiten Kreuzung von nebenan wartenden Leihroller-Fahrern über mein Moped ausgefragt werde, kann ich auch mal allen eine Zusammenfassung dalassen: Ich habe mir vor zwei Jahren einen Unu-Roller mit einem 3kW-Motor gekauft und einen zweiten Akku dazu.

Die wichtigsten Kenndaten [3]: nominelle Reichweite mit beiden Akkus 100 km, realistisch: 80 km. Die letzten fünf Kilometer fährt man nur noch 20 km/h. Ladegeschwindigkeit (pro Akku) sind 10 km/h, zweites Ladegerät zu kaufen lohnt, Y-Kaltgeräte-Adapter für die Reise auch. Akku wiegt so 8-9 kg, kriegt man mit Tragegurt (ist bei) auch mal zwei Treppen hoch. Moped wiegt weniger als ich.

Zuallererst: Im realen Leben ist die Reichweitenangst vollständig unbegründet. In den letzten zwei Jahren Regulärbetrieb bin ich genau einmal liegengeblieben. Hört sich erstmal doof an, heißt aber nur, dass man seinen Akku rausholen per ÖPNV heimbringen, aufladen und zurückbringen muss. Mit meinem Verbrenner bin ich mehrmals im Jahr leergefahren und musste dann tatsächlich schieben oder Kanister organisieren, befüllen und mich mit dem Taxifahrer streiten, die stinkende Plastebox per Kurzstrecke mitnehmen zu dürfen.

Das Aufladen geht durch einen ganz einfachen Effekt in die tägliche Routine über: Zwischen 75 % und 100 % Akkuladung pumpt der Motor-Controller an der Kreuzung nochmal extra Strom in den Motor, darunter verhält er sich konservativer. Soll heißen: Je voller der Akku, desto mehr Fahrvergnügen an der Ampel. Das konditioniert von ganz alleine darauf, den Akku zum Laden mit reinzunehmen. Für längere Strecken innerhalb der Stadt nehme ich daher immer zwei volle Akkus mit, wenn eins dicke reichen würde.

Für einen Trip in die Pampa sollte man sich im Umkreis von 75 km ein Restaurant suchen, in dem man seine Akkus aufladen darf. In zwei Stunden bekommt man in der Summe rund 40 km drauf. Der Rest ist Mathematik. Wenn alles gut geht. Bei meinem ersten Testtrip ging leider nicht alles gut. Das Hinterrad hatte aufgrund einer kleinen Delle in der Felge subtilen Luftverlust. Und platte Reifen sind der natürliche Feind der Reichweite. Das kurz vor Bernau festzustellen, brachte mir die ganze Tourplanung durcheinander [4] und machte, dass ich am Ende doch noch mit der U-Bahn den Akku nach hause fahren musste.

Das Problem artete sogar noch aus, und das lag absurderweise daran, dass ich mein Moped ganz leise wollte. Die meisten E-Roller kommen mit einem unangenehmen Plaste-Surren daher. Da ich mich nach zwei Jahrzehnten Rasselmotor Fahren darauf gefreut hatte, majestätisch durch die Nacht zu gleiten, sind diese Roller ein No-go für mich. Das Geräusch stammt (soweit ich das beobachten konnte) vom Riemenantrieb – der Motor ist unter dem Sitz und die Kraft muss auf's Hinterrad. Die Unus haben hingegen einen Nabenmotor direkt im Rad eingebaut und produzieren außer dem Reifen-Fahrbahn-Geräusch [5] keinen Ton. Leider hat sich Unu entschieden, die Felge fest auf dem Motor zu verschweißen. In der Werkstatt wollten sie daher für die defekte Felge (eBay-Preis gebraucht 'n Zehner) ungefähr den Neupreis des Motors haben. Nach einigem Grübeln kam dann die Werkstatt darauf, die Felge geradezuhämmern und einen Schlauch einzuziehen. Muss man wissen. Seitdem hatte ich keine überraschenden Reichweitenprobleme mehr.

Unüberraschend kommen die nur im Winter. Kalte Akkus sind zickig – so ab 0 Grad. Nehmt die rein. Eiskalte Akkus machen, dass der Motor kaum noch anzieht und die Reichweite einbricht – wenn man überhaupt noch Lust hat, die auszufahren. Ansonsten ist das Moped auch im Winterbetrieb tauglich. So richtig meterhohen Schnee zum Testen hatten wir leider nicht. Obwohl ich diesen Winter nur schwer testen konnte. Das lag daran, dass man mit dem Unu super einkaufen fahren kann.

Im Fach unter dem Sitz passen zwei Akkus nebeneinander rein. Wenn man eins rausnimmt, passt ein kompletter Rewe-Einkaufskorb [6] rein. Und dann ist zwischen den Beinen immer noch Platz. Bei einem späten Einkauf – meine Kaufhalle hat 24/6 auf – habe ich in einer Novembernacht das volle Einkaufsprogramm mitgemacht und mir noch eine TKP [7] in der linken Hand balanciert. Wie das dann halt so ist, habe ich elegant mit dem Knie den Pizzakarton unglücklich gegen das Lenkrad geschoben, das mich prompt gegen einen fies platzierten Poller lenkte. [8] Die Geschichte des Pärchens, das mir beim Zusammensammeln von Verkleidungsteilen und Einkäufen half, im Tausch gegen die Benutzung meines Mobiltelefons, würde noch einen ganzen Blogpost füllen. Ein paar strukturell wichtige Teile wie Blinker und Fußstellflächen waren ab, daher musste ich zur Werkstatt und wurde dann von den Freuden deutsch-chinesischer Handelsfreundschaft überrascht:

Unu wechselte Mitte 2017 den Zulieferer für die Ersatzteile, der wiederum eine ganz eigene Idee von Vorratshaltung hatte. Als bei dem die Bestellungen für die Karosserieteile eingingen, fingen die erst an, die Produktion dafür binnen Monatsfrist zu planen. Kurzum: nach einem Vierteljahr hatte ich meinen Roller wieder. Zum Glück war ich ein gut Stück dieser Zeit eh nicht im Lande. Bisschen peinlich ist es trotzdem, wenn sie jetzt auch – nach eigenen Beteuerungen – die Lieferkette wieder im Griff haben.

Eins noch: Das erste, zu dem mich die mir zugeteilte Bosch-Vertragswerkstatt zu meinem Roller fragte, war der Zustand der Spiegel. Und tatsächlich, so ziemlich alles an den Spiegeln wirkt wacklig: Allein weil das Moped so leicht ist, zittern die Spiegel schon auf asphaltierten Straßen ganz verwirrend, auf Kopfsteinpflaster braucht man sie gar nicht zu benutzen versuchen. Die Konterschrauben unten an den Spiegel muss man mit echtem Werkzeug nachziehen, sie lösen sich sehr gern von allein. Unu legt aus Verlegenheit schon den passenden 15-er Schlüssel zum Handbuch bei. Die kleinen Blinker/Licht-Konsolen, auf denen sie draufstecken, geben auch irgendwann nach, drehen sich dann so leicht nach vorne und hinten und wurden bei mir schon drei mal gewechselt. Aber dafür sind die Spiegel schick!

Kurzum, wie das so ist als early adopter einer hippen Technologie: Man macht alle Kinderkrankheiten einmal mit. Zwischendurch war die Frustration durchaus da, mich auch nach anderen Anbietern umzuschauen. [9] Meine Probleme sind aber fürs erste gelöst, die Lösungen für andere Betroffene runterzuschreiben, war auch Motivation für diesen Text. Ich weiß jetzt nach zwei Jahren ziemlich genau, woran ich bin, meine Akkus tun immer noch und fühlen sich nach zwei weiteren Jahren Stadtbetrieb an. Und auf ein neues Akku- oder Ladesystem umzusteigen, ist mit impliziten Kosten verbunden, zudem würde ich bei anderen Herstellern eben auch nochmal alle Kinderkrankheiten mitnehmen und die wären wiederum neu und überraschend. Daher bleibe ich erstmal bei meinem Model.

Since letsencrypt has made it easy to actually get the little green lock icon in all the browser, I've deployed it nearly everwhere, where reloading keys every three months is not an issue (looking at you, dovecot and ejabberd). When using FreeBSD, the security/dehydrated port has made things smooth enough for me not to be to afraid to execute it from a periodic script: It only requires bash and curl and can be executed as non-privileged user.

So here's a step by step instruction how to properly set it up:

1. Install the port/package:

   pkg install dehydrated

2. Create the letsencrypt user, for example:

   echo letsencrypt::::::::/bin/sh: | adduser -w random -f -

3. Create your config copy /usr/local/etc/dehydrated/config by duplicating the example:

   cp /usr/local/etc/dehydrated/config.example /usr/local/etc/dehydrated/config

4. Edit /usr/local/etc/dehydrated/config so it reads CONTACT_EMAIL=me@foo.com. (Don't forget to remove the # at the line's start.)

5. By default, dehydrated's work dir is /usr/local/etc/dehydrated. I do not like that, because the letsencrypt user needs write access to that directory for its housekeeping files and could modify things like the config and – worse – the deploy.sh script. So I create a different work dir:

   mkdir /var/dehydrated
   chown -R letsencrypt /var/dehydrated

6. And then I change /usr/local/etc/dehydrated/config to read BASEDIR=/var/dehydrated. (Again, don't forget to un-comment the line.)

7. The web directory for challenge replies defaults to /usr/local/www/dehydrated. It needs to be writable by letsencrypt user:

   chown -R letsencrypt /usr/local/www/dehydrated

8. Configure domains.txt:

   echo 'foo.com www.foo.com' > /var/dehydrated/domains.txt

9. I want dehydrated to be run weekly by periodic, I also setup the deploy script (see below). I put those lines in /etc/periodic.conf:

   weekly_dehydrated_enable="YES"
   weekly_dehydrated_user="letsencrypt"
   weekly_dehydrated_deployscript="/usr/local/etc/dehydrated/deploy.sh"

10. The deploy.sh script needs to be setup, it will tell all frontends to reload certs. For my nginx installations, it is enough to put this into /usr/local/etc/dehydrated/deploy.sh:

    #!/bin/sh
    
    /usr/sbin/service nginx reload

11. Don't forget execute permissions:

    chmod +x /usr/local/etc/dehydrated/deploy.sh

12. Finally, for nginx to correctly route requests to the web dir, add this to your server block. Don't forget to enable listen 80:

    location /.well-known/acme-challenge/ {
        alias /usr/local/www/dehydrated/;
    }

13. Before running dehydrated for the first time, you should reload your nginx config. This also is an implicit check for correct permissions on deploy.sh ;):

    /usr/local/etc/dehydrated/deploy.sh

14. Run dehydrated to set up and agree to terms and conditions:

    su letsencrypt -c 'dehydrated --register --accept-terms'

15. Then run it again to actually do a challenge/response and generate certs:

    su letsencrypt -c 'dehydrated -c'

16. If everything went fine, tell nginx to use the new certs in your server block. Don't forget to enable listen 443 ssl:

    ssl_certificate /var/dehydrated/certs/www.foo.com/fullchain.pem;
    ssl_certificate_key /var/dehydrated/certs/www.foo.com/privkey.pem;

17. Make nginx use your new certs:

    /usr/local/etc/dehydrated/deploy.sh

You should be able to see your web site with a little green lock icon now, carrying a letsencrypt cert.

In order to verify that all your setups have been setup correctly, I wrote a script that checks them all:

HOSTS="mail.foo.com:25:smtp mail.foo.com:imaps www.foo.com jabber.foo.com:5232"
unset LANG LC_CTYPE LC_MESSAGES LC_TIME

for host in $HOSTS; do
  unset starttls
  [ ${host%:*} = ${host} ] && host=${host}.:443
  if [ ${host%*:*:*} != ${host} ]; then
    starttls="-starttls ${host#*:*:} "
    host=${host%:*}
  fi
  echo $host ${starttls}
  notafter=$( yes q | openssl s_client -servername ${host} -connect ${host} ${starttls} 2>/dev/null | openssl x509 -noout -enddate | grep ^notAfter= | cut -d = -f 2- )
  secs=$( date -j -f "%b %d %T %Y %Z" "${notafter}" +%s )
  now=$( date +%s )
  printf "% 4d days .. until %s\n" $(( (secs - now) / 86400 )) "${notafter}"
done

Ever since poudriere was published, I felt the obligation to run a public repository with packages tuned to my needs (i.e. without X11, without Java, with a certain TLS library as default, etc). But considering this tool's complexity, I never felt comfortable running it on a production system's host. So naturally I've been looking for a way to jail it away and only 2 years after this tutorial outlined how that works, I managed to acutally try it out. Long story short: This guide kinda works and I got poudriere running in a jail. But I want the jail to automatically start up, get the correct dataset attached and receive all permissions needed to do zfs stuff and creating its own builder jails, in other words: I wanted to embed it as an ezjail.

Now, turns out, that's actually not so hard: If you're running ezjail with zfs enabled, you first create the dataset for poudriere to work on:

zfs create -o jailed=on tank/poudriere

then you just create your poudriere jail, making sure to pass it an ::1 IP address:

ezjail-admin create -c zfs poudriere 127.0.0.1,lo0|::1

and then manually edit the two config lines in /usr/local/etc/ezjail/poudriere to read:

export jail_poudriere_parameters="children.max=10 allow.mount=1 allow.mount.devfs=1 allow.mount.procfs=1 allow.mount.zfs=1 allow.mount.nullfs=1 allow.raw_sockets=1 allow.socket_af=1 allow.sysvipc=1 allow.chflags=1 enforce_statfs=1"
export jail_poudriere_zfs_datasets="tank/poudriere"

dont forget that this jail needs a resolv.conf, too and now you can just:

ezjail-admin console -f poudriere

and follow the FreeBSD handbook section on poudriere to get your poudriere jobs running. Since I wanted the web server jail to serve the packages, I exposed them in /etc/fstab.www_domain.com by adding a line:

/usr/jails/poudriere/tank/poudriere/data/packages /usr/jails/www.domain.com/packages nullfs ro 0 0

and after an ezjail-admin restart www.domain.com, you should be able to use the packages built by adding a /usr/local/etc/pkg/repos/www.conf of:

www: {
  url: "file:///packages/103amd64-local-workstation/",
  enabled: yes
}

Update: Should you be missing the file systems inside your poudriere jail, make sure to mount them in your periodic script that runs poudriere (using zfs mount -a, before running poudriere), or take a look at the thread on the ezjail mailing list regarding rc.d/zfs not finding the dataset when it's run.

Seit September bin ich e-mobil. Ich bin mein ganzes Führerschein tragendes Leben lang auf Mopeds durch Berlin geheizt, beginnend bei einer Schwalbe, seitdem immer mit lauten und müffelnden Zweitaktern – bei entsprechendem Verschleiß. Ich wollte vermeiden, mehrere Tonnen Stahl durch die Gegend zu hieven, wenn ich doch nur meinen Hintern von A nach B bewegen wollte, und habe daher trotz mehrerer Autos auch immer noch als primäres Fortbewegungsmittel ein Moped beibehalten. [1] Trotzdem ist der wohlige Geruch von Zweitaktabgasen, der harmonische und weit wahrnehmbare Klang nicht unbedingt das Omen, das man seiner Ankunft voraussenden möchte – und die Wartungsanfälligkeit dieses fragilen Haufens beweglicher Teile ließ mich schon vor einer Weile die Fühler in Richtung Elektroroller ausstrecken.

Zwar gab der Markt seit sechs, sieben Jahren auch welche her – allerdings schreckten die Preise im Bereich einer Kleinwagenneuanschaffung ab und meine guten Vorsätze verschwanden schnell wieder in der Schublade. Und die frühen Reichweiten-Angebote von so 25 bis 30 Kilometern haben nichts mit den Strecken zu tun, die ich an einem terminlich gut befüllten Tag in Berlin so in die Reifen schrubbe. Mein Reichweiten-Maßstab ist die Sommerresidenz von Freunden nahe Berlin, für die ich rund 80 Kilometer runterreißen muss – jaja, kein Spaß auf einem geschwindigkeitsbegrenzten Kraftfahrzeug, und auch auf meinen Verbrennern hatte ich unterwegs schon eine Stammtankstelle auserkoren. [2] Aber zumindest kann ich mal eben ranfahren, "Kaffee" kaufen und weiterfahren. "Mal eben" Akkus aufladen kannste hingegen knicken.

Schon vor ein paar Jahren [3] startete die Firma Gogoro in Taipei einen Dienst, bei dem man sich um das Laden nicht mehr kümmern muss, sondern die Akkus an Straßenecken im Späti leer gegen voll tauschen kann. Die sind nun als Mietmobile nach Berlin expandiert [4], jedoch finde ich die weder gutaussehend noch gutklingend. Aber hohe Absatzzahlen ziehen ja auch immer sinkende Preise nach sich und richtig:

In den letzten Jahren hat sich da so richtig was getan: Die Preise für Elektromotoren und Batterien sind gepurzelt – nicht zuletzt durch die krassen E-Mobilisierungsprogramme in China und Indien [5], Ladezeiten und Energiedichten kommen in erträgliche Größenordnungen und ein Berliner Unternehmen bietet Hipster-geeignete Scooter zum Kampfpreis an. [6] In der Rechts-Unten-Vollausstattung mit zwei Akkus ist man schon mit 3,5 k€ [7] dabei – das ist nur marginal mehr, als ich in meine alten Benziner investiert habe. Und das liegt vor allem daran, dass an so einem E-Roller nix mehr dran ist:

Nabenmotor im Hinterrad nebst Motorsteuerung, einigermaßen stabiler leichtgewichtiger Rahmen, quasi ein besseres Fahrrad, Akkufach und Sattel. Also habe ich zugeschlagen und fahre seit September quasi durchgängig E-Roller im Berufsverkehr. Und ja, es rockt: Kaum bewegliche Teile, so ein Elektromotor ist im Vergleich zu einem Verbrenner trivial und hält gern mal zig Jahre. Gut, bisschen Bremskram, Tacho und Verkleidung, aber im Prinzip war's das. Und als mir das Akkufach wegen eines unglücklichen Steinschlags an einer Ecke rausgebrochen ist, gab's vom Hersteller ein Paket mit einem tiefgezogenen Plasteteil, das ich mit einem Schraubendreher in 10 Minuten selber tauschen konnte. Ich kann im Prinzip für die nächsten zwanzig Jahre mit dem Gerät fahren, ohne nennenswerte Wartungskosten zu haben.

Und dann der Verbrauch: Aufladen geht mit 220 V, Netzteil ist bei und lädt in rund vier Stunden voll. Die Hersteller-Angaben von "70 % aufgeladen in einer Stunde" sind doch ein bisschen optimistisch, aber eine komplette Ladung bekomme ich zuhause für rund 30 Cent. Da ich nicht erst tanke, wenn die Akkus leer sind, ist der genaue Preis schwer zu schätzen, aber meine monatlichen Ausgaben für's Tanken sind von 60 Euro auf 6 Euro gesunken. Und das noch in den ersten Monaten, wo mich der Fahrspaß das Moped noch deutlich häufiger benutzen lässt. Und Fahrspaß it is!

Das Moped, was ich mir ausgesucht habe, ist im Vergleich zu den Leihrollern von eMio und Coup rund 20 % kleiner und deutlich leichter – und jedes am Roller gesparte Kilo muss ich nicht abnehmen, um an der Ampel schneller wegzukommen. Entsprechend saust es sich an der Kreuzung auch los. Danach gleitet man quasi durch den Straßenverkehr und viel toller: durch Parks und über Fahrradwege und Bürgersteige, ohne negativ aufzufallen. Um das Moped am Café abzustellen, bin ich auch schon durch die Stuhlreihen auf dem Gehweh gerollt und niemand hat auch nur geguckt – mit dem 2-Takter undenkbar. Und wenn man einen Sozius an Board hat [8], ist sogar ein entspanntes Gespräch möglich.

Tzschja, und der Pferdefuß? Die Reichweiten-Experimente sind nicht vollständig geglückt: Vollständig leer kann (und sollte man) das Akku nicht realistisch fahren, da auf den letzten 15 % Ladestand ein bequemes Fußgängertempo rauskommt [9]. Und auch dann landet man nicht bei den 50 Kilometern Distanz, sondern eher so bei 45, von denen man nur die ersten 40 vorankommt. Selbst mit den beiden Akkus sind die 80 Kilometer zur Datsche [10] des Kumpels also nicht (oder nur ohne Bremsen und mit viel Bangen) ohne Zwischenstopp zu erreichen. [11] Das heißt, dass ich mir jetzt ein Restaurant suchen muss, wo ich auf dem Weg kurz zum Schnitzel Essen anhalten und währenddessen zwei Akkus kurz-betanken muss. Hmm.

Auch ansonsten ist die Kapazität noch nicht da, wo man überhaupt nicht mehr drüber nachdenken muss: Die Akkus selber wiegen so acht Kilogramm und kommen mit Henkel: Mit Erdgeschoss-Büro ist das Tauschen schon in die tägliche Routine übergegangen, weil der Motorcontroller auf den ersten 25 % Akku noch einmal spürbar schneller anzieht und daher ein volles Akku spaßsteigernd ist. [12] Allerdings ist es nicht so, dass ich ernstlich leide, wenn ich mal zwei Tage das Tauschen vergessen habe, also kein nervöses Hetzen wie beim Smartphone. Was die Kapazität angeht, bin ich verdammt nah am Wohlfühlbereich dran, und wenn von den wöchentlichen Presseberichten über eine Verdopplung und Verdreifachung der Energiedichte in Akkus im Labor [13] auch nur eins die Serienreife erreicht, erreiche ich die Auftank-Frequenz des Benziners.

Da ich auch stolzer Winterfahrer bin, habe ich ein paar Erfahrungen mit den Akkus in der Kälte gemacht. Grundsätzlich gilt: Akkus nicht nachts draußen parken. Und wenn man sie tagsüber ein paar Stunden in der Kälte lässt, zieht das Moped nochmal deutlich schlechter an und man verliert bei Frost rund 10 % Reichweite. Kein Showstopper, aber sollte man beachten.

Das einzige, was mich beim Unu ein bisschen ankekst, ist die Helmsituation. Das Akkufach ist riesig, und wenn man nur einen Akku mitnimmt, hat man echt viel Stauraum für einen mittleren Einkauf. [14] Jedoch ist das Akku quaderförmig hoch (es passen also zwei nebeneinander), was keinen Platz mehr für einen normalen Helm lässt. Sinnigerweise passt der Helm prima rein, wenn kein Akku drin ist: Aber ganz ehrlich schleppe ich lieber Helm statt Akku mit. [15]

Nun kann ich also mit gutem Beispiel voran Energie sparend durch die Stadt heizen und meine Gesamtökobilanz wieder massieren. Beim Recherchieren bin ich noch auf das offensichtlich weit verbreitete Vorurteil gestoßen, Elektro-Mobile würden ja viel dreckiger betrieben werden, als Benziner, da der Strom aus Kohlekraftwerken käme. Gilt für mich zwar nicht, aber noch krasser ist, dass die meisten Raffinerien Benzin mittels Kohlestrom herstellen [16], der die Bilanz pro Kilometer sofort wieder Richtung Elektro-Mobil korrigiert. Und Meldungen wie die hier [17] machen mir Mut, wirklich Sonnenkraft unterm Hintern zu spüren – Proctoheliose FTW!

Fußnoten:

Twelve years ago I started a little project called ezjail, an opinionated tool that helps FreeBSD admins to make compartmentalization a lot easier. Long before real virtualisation was a real thing for the rest of us, it helped me scratch my itches maintaining virtual servers I could give out to my more or less technically savvy friends without too much headaches regarding the safety of my files. Of course, this project has been released under my favorite licence.

Keep in mind, that this licence actually doesn't ask for much. Basically it only says not to steal it and run around claiming it's yours. Now, you'll never guess, what happened in 2013. ;)

That's right: After apparently not reacting quickly enough to some man page rewrites submitted to me by an author from the philippines, I seem to have made an enemy for life! I've encountered an interesting version of a hostile fork named qjail: my project was copied, the fork renamed and most (but not all) of the references to the ezjail project name replaced by the fork's name.

When I reported my astonishment to the adults running the FreeBSD project, they quickly took action and blocked the port until qjail acknowledged me being the author. Others noticed as well and decided to move away from the copy cat.

The open source philosophy and some licence law details must have been lost on the guy, as becomes obvious by some later quite funny follow-ups. To quote from emails later in that thread (you have to start reading from the bottom).

One does not have to be a lawyer to know the lack of any license verbiage embedded in computer programs released to the public becomes property of public domain forever. Putting license verbiage on your next port version is unenforceable because it's already property of public domain.

And even more hilarious

This outburst only confirms my suspicion that your suffering from dementia caused by advancing age. I tried to give you a way to save face as I purposed in my private email to you.

I understand what you are going through and forgive you for your actions. I pray you are under medical care for this condition. There are drugs which reduce these effects and prolong the periods of normalness.

While I usually try not to stand in the way of others doing stuff, I found the process annoying enough to act. In turn, ezjail became a constant target of FUD and suggestions to switch in all kinds of forums I never had the time to check and correct.

What made things worse is that the guy just started learning the very language ezjail was written in. Considering jails being a security mechanism, that's a very bold move.

In the end, the differences in qjail became so distinct that he could not rip off later developments like the whole zfs sub system, contributed by a friend of mine.

Time went by and things changed in the FreeBSD world that were a little unfortunate to my project: FreeBSD jails were reorganized and the official jail management tool moved from reading a simple config language to a structured one (making it impossible to edit and parse in the rather simple scripting language sh). A legacy wrapper was added which showed a depreciation message every time ezjail would start a virtual system:

WARNING: Per-jail configuration via jail_* variables is obsolete. Please consider to migrate to /etc/jail.conf

Of course, this only was grist to the FUD mill, claiming ezjail was outdated. For technical reasons, while it is easy to get rid of this warning (qjail did), but unfortunately not when doing it properly. (Tl;dr: you can reproduce the original functionality of the wrapper, but you're doomed to chase changes in the system's implementation forever. Also you keep several, possibly diverging states of your config files without a way to parse the ones that the OS considers official.)

If you zoom out on the thread I just linked to, you'll notice that the very guy who stole my code now lobbies to have the wrapper code removed, which would essentially break ezjail.

And to make things even more absurd: when called out on his proposal, he approached me with a "fix" to the carnage he tries to bring upon me. You'll never guess if he wrote the code he asks me to copy into my project himself. ;)

In summary: I can't really lurk around in all the forums and honestly I don't have the time for fighting an unsuspected arch enemy. But if you want to understand how frustrating open source development can become, once you're up against someone with more time than ability, feel free to join me over a beer!

Das Boot ist voll! Die Hackerszene wird überlaufen von lauter „Möchtegernhackern“. Im Hackcenter leuchten angebissene Äpfel statt Pinguinen. Und jetzt nehmen uns diese ganzen Hipster noch die Arbeits^WKonferenzplätze weg – und die können noch nicht mal Assembler! Wer nicht mal unsere Sprache lernen will und sich selber einen Vorverkaufs-Bot hacken kann, was will der überhaupt auf dem 33C3!??! Wo sind die goldenen Zeiten geblieben, als man noch wer war, noch unter sich? Und im Hackcenter gab's Pornos zum Tauschen! Und dann hält eine Frau die Keynote?! Und noch eine aus Afrika? Und programmieren kann die auch nicht! Der CCC war mal Club und Veranstaltung, da ging es um Computer!

Oder?

Ich kann das Gemaule abgehängter und abgehalfterter Möchtegern-„Hacker“, die in ihrem Leben außer dem regelmäßigen Installieren ihrer Lieblings-Linux-Distribution wenig Nerdiges hinbekommen haben, nicht mehr hören. Wer meint, der CCC definiere sich hauptsächlich über Computer, Hard- und Software, hat die Historie des Vereins nicht verfolgt. Beim ersten öffentlichen Hack, dem HaSpa-Hack, ging es nicht primär darum, dass die Nerds super programmieren konnten. Es ging immer darum, über den Tellerrand hinauszublicken, Wissen in Erfahrung umzusetzen und Transferleistungen aus anderen und in andere Wissensgebiete zu erbringen. Nicht umsonst heißen die CCC-Dezentralen „Erfahrungsaustauschkreise“. Die Arroganz, Nerds gäbe es quasi nur durch und mit Keyboard, die sich da durch Twitter und Heise-Foren wabert, ist erschütternd. Ich glaube ja, erst der Zuzug von und die Öffnung hin zu den wahrhaft Begabten aus anderen Disziplinen hat den Computer-Hackern die gesellschaftliche Relevanz eingebracht, derer wir uns jetzt rühmen. Und der Austausch ist auch für uns Keyboard-Nerds fruchtbar: Gestalter machen unsere Software nutzbar und ansehnlich. Das Wissen von Generationen von Projektplanern macht unsere Software überhaupt erst fertig. Und erst der Bedarf der Welt an diverser Software FÜR alle Fachbereiche ermöglicht es uns, aus unserem Hobby ein Auskommen nach Hause zu tragen.

Historisch betrachtet hat sich das Internet zum mächtigsten Werkzeug der Nerds aller Wissensgebiete gemausert: Denn um vor zwanzig Jahren Gleichgesinnte in seinem Orchideenfach zu finden, musste man entweder zu teuren jährlichen Fachkonferenzen fahren oder sich mit den vom Munde abgesparten Fitzelchen an Fachliteratur Zugang mühsam selber erschließen. Und ja, anfangs war dabei schlicht das Medium die Nachricht. Damals war man eben was Besonderes, wenn man „was mit Computern macht“. Heutzutage ist man eben was Besonderes, wenn man nix mit Computern macht. Deal with it. (Und wenn wir ehrlich sind, drehte sich auch damals die Hälfte dieses Internets um die Soap-Operas mit James T. und Jean-Luc.)

Wer wirklich Hardcore-Security-Nerds beim Blackhatten begaffen will, für den sind da draußen dutzende Kommerzkonferenzen gewachsen. Das ist aber nicht der Grund für das Wachstum des Congress. Wir haben – ganz im Gegenteil und als Realwelt-Spiegel des Internets – eine nichtkommerzielle Vision unserer Zukunft aufgebaut, in der man auch und gerade als Orchidee willkommen ist, solange man teilnehmen und nicht nur besuchen will. Wir finden uns als Teilnehmer mit einem Hacker-Mindset zusammen, die sich in allen Fachgebieten wiedererkennen. Man sehe nur in den Track „Science“: Sogar aus der drittmittelverseuchten und publikationsnormierten Academia können wir freudig Agrar-Nerds gewinnen, die sich ihre Meriten buchstäblich durch Arbeit verdient haben und diese auf dem Congress mit anderen teilen wollen.

Statt laut pöbelnd einen Altnerd-Brexit zu fordern, müssen wir die Arme weiter aufhalten und unseren Hacker-Kultur-Raum arroganzfrei allen anderen Nerds zum Kopieren vorleben.

Ab wann wird aus einer Masse von selbstbestimmten Menschen, die sich durch das Verteilen ihrer Sensorik ins Netz und dem Optimieren ihrer Routen und Handlungen mit Hilfe eines Algorithmus Reibungsverluste im täglichen Leben ersparen wollen, eine Masse von fremdbestimmten Menschen?

Momentan fluten Hunderttausende die Straßen auf der Suche nach Poke-Stops, die teilweise von Betreibern nahe liegender Shops gefüttert werden und teilweise findige Bauchladenverkäufer anlocken. Doch zuweilen führen Fehler in der Datenbasis dazu, dass nachts Gestalten vor ehemaligen Kirchen rumlungern und die Cops den neuen Besitzer des Hauses für einen Dealer halten.

Dieses Problem des unfreiwilligen Fleshmobs ist nicht unbedingt neu: Begabte Trolls haben schon verabredungswillige Männer auf einen Haufen zusammengelockt und andere wiederum folgen freiwillig Weganweisungen, deren Ziel sie nicht kennen, aber deren Ziele sie unterstützen. Daniel Suarez hat in “Daemon” eindrucksvoll beschrieben, wie sich weiterhin selbstbestimmt fühlende Menschen zu den fleischgewordenen Ausführenden eines Algorithmus werden können, wenn man ihre Anreize mit den ürsprünglichen Zielen des System-Betreibers in Übereinklang bringt.

Längst lassen wir uns in weiten Teilen unsere Lebens trotz besseren Bauchgefühls von Navigationsalgorithmen entlang für uns maßgeschneiderter Routen führen. Der Algorithmus wird sich schon etwas dabei gedacht haben: Eine eventuell längere Strecke kann überhaupt erst dazu führen, dass die kürzere nicht verstopft ist. Warum man ihm trotzdem folgen sollte? Aus dem selben Grund, warum man nachts an der roten Ampel stehen bleibt: Das Vertrauen darauf, dass alle anderen den Anweisungen genauso folgen und man nicht extra an jeder Kreuzung mühsam gucken muss.

Wenn man gleich dabei ist, könnte man doch die Route für alle anderen dynamisch neu gewichten, wenn ein Krankenwagen ansagt, wo er entlangfahren muss. Und wenn die Protokollstrecke für Staatsbesuche schon im Vorfeld aus dem Routing fällt, müssten Motorradpolizisten viel weniger Fahrzeuge anhalten? Und wieso nur staatliche Stellen? Können nicht Fremdenverkehrsvereine verschiedener Kurorte Navi-Herstellern in einer Auktion Anreize geben, alle Fahrten (außer den Patienten natürlich) um den eigenen Ort herumzuleiten? Andere Orte freuen sich eventuell über zahlende Durchgangsreisende.

In der Realität folgen schon heute viele Menschen in ihrem Beruf den Anweisungen der zentralen IT. Für die Befüllungskräfte in Amazon-Warenhäusern entscheidet der Algorithmus die kompletten Arbeitsabfolgen während der Schicht. In Banken sind Kundenbetreuer längst zu Computer-Vorlese-Mannequins verkommen, die Ergebnisse des Kreditbewertungsalgorithmus vortragen. Und selbst, wenn wir in unserem Berufsleben nicht direkt von Entscheidungen eines Computers abhängig sind, so begegnen uns die Auswirkungen in der Behördeninteraktion.

Prinzipiell ist die Idee des Vorschußvertrauens Staat => Bürger mit einer randomisierten oder gesteuerten Nachprüfung mit hohen Strafandrohungen keine schlechte. Aber wer z. B. eine Steuer-Tiefenprüfung zu erdulden hat, wird anhand einiger, für die in Bewegung gesetzten Steuerprüfer nicht direkt ersichtlicher Parameter bestimmt. Die holländische Polizei rühmt sich dabei gar, bei Verdächtigen, denen sie nicht direkt etwas nachweisen kann, durch diese “Systemlotterie“ Reibungsverluste zu erzeugen, um sie auf Spur zu halten. Die dabei dann aus allen möglichen Institutionen einreitenden Bediensteten wissen dabei nicht zwangsläufig, dass sie ein kleines Rädchen in einer zielgerichteten Kampagne sind.

Doch während hier noch ein Mensch die Entscheidung trifft, gibt die automatisierte Auswahl “interessanter” Ziele für eine tiefere Untersuchung mehr Anlass zur Sorge. Wenn man das soziale Wirken von Personen in der Gesellschaft statistisch betrachtet, ergibt sich in den meisten Modellen eine Gaußverteilung. Und an den Rändern der Glockenkurven wird es für den Algorithmus interessant: Wer von der Norm abweicht, gibt mehr Anlass zur genaueren Überprüfung. Wenn alle Behörden die selben Kriterien zur Zielpersonenfindung ansetzen, sieht sich der Betroffene auf der Empfängerseite einer Flut eigentlich komplett unabhängiger Entscheidungen unterschiedlichster Institutionen. Wie sich das anfühlt, können Opfer von "racial profiling" eindrucksvoll berichten.

Nun, was für den Einen Hort von Kriminalität und Niedertracht, ist historisch gesehen Keimzelle gesellschaftlichen Fortschritts, Widerstand gegen ungerechte staatliche Repression, Quelle von Kunst, Kultur und neuer politischer Ideen. Gewiss gibt es Teile der Bevölkerung, die so ein automatisiertes Rundlutschen des Verhaltensspektrums im Rest der Gesellschaft guthieße. Doch wenn uns an einer selbstbestimmten kulturellen Entwicklung etwas liegt, sollten wir der Dienstanweisungen aus dem Algorithmus mit gesundem Menschenverstand und einer gehörigen Portion Skepsis begegnen.

Und bis dahin sollte man weiter die Frischluft-Dusche beim Pokémon-Go-Spielen mitnehmen.

In recent years I have participated in the organisation of the congresses held by CCC and have seen many recurring problems with talk submissions. Here are some hints how to reduce future frustration when great talks are rejected due to bad abstracts.

In den letzten Jahren habe ich mich an den Planungen der Congresse des CCC beteiligt und dabei einige wiederkehrende Probleme mit den Einreichungen erlebt. Folgende Hinweise sollen dabei helfen, zukünftig Frustrationen zu vermeiden, wenn gute Vorträge wegen schlechter Beschreibungen nicht angenommen werden.

ezjail 3.4.2 is out, fixing a problem that occurs if ezjail-admin is run from scripts to destroy and re-create jails. It also brings a new experimental freeze feature, allowing to dump zfs diffs between jail initialisation and freeze time into an ezjail flavour. Update Now in ports.

Nun hat es auch den Chaos Computer Club erwischt. Nicht nackte weibliche Brüste, Schimpfwörter, das Angebot von Funktionalität, die Apple auch gerne anböte, sondern schwammige Ausreden über "Informationen, über das Hacken von Apples Betriebssystem" waren Auslöser, eine bequemere Abspielmöglichkeit für Mitschnitte unserer Congresse zu verbieten, als beispielsweise youtube oder Safari es wären (die ironischerweise die selben Filme abspielen können, ohne aus dem Store zu fliegen).

Die hochnäsige Selektionspolitik von Apple auf seinen Marktplätzen hat der Firma ja schon eine eigene Wikipedia-Seite beschert und noch immer gibt es Apologeten, die Apple Narrenfreiheit auf ihrer Plattform zugestehen wollen. Ich will mich am juristischen Gekloppe gar nicht groß beteiligen, sondern ein paar Denkanstöße aufschreiben, bevor ich sie wieder vergesse.

Szene 1: Vor einiger Zeit gab es bei den traditionellen Straßenfesten eine Konsolidierung: Eine Event-GmbH übernahm Planung, Standanmeldung und Durchführung einer beträchtlichen Anzahl dieser Veranstaltungen. Würde man dem Betreiber zugestehen, nach Gutdünken NGO wie Greenpeace die Anmietung eines Standplatzes verbieten zu lassen?

Szene 2: Durch die Vermallung der Innenstädte ist der freie Zugang zu Angeboten der sozialen Grundbedarfsdeckung wie Kino, Buchhandlungen, der Post oder gar Zugängen zum ÖPNV in Konflikt mit Interessen der Betreiber solcher halböffentlichen Räume getreten. Kann der Betreiber der Mall nach Gutdünken Hausrecht durchsetzen und Einzelnen den Zugang zu den Angeboten verwehren?

Mehr noch: Kann und darf der Betreiber der Mall Einfluß auf Angebote und Auslagen der Geschäfte nehmen? Ist das Konzept des öffentlichen Raums eine sozialromantische Utopie des zwanzigsten Jahrhunderts? In wieweit sind die auf Immersion optimierten Portale und Digitalgut-Großmärkte als Digitalanalogie einer Mall zu vergleichen? Sind beim Betrieb durch Multinationale automatisch moralische Befindlichkeiten der Heimatländer eines Unternehmens maßgeblich?

Szene 3: Ein Zeitungsgroßhändler ist in einer investigativen Recherche einer Zeitung nicht so gut weggekommen und beschließt nun, den Verlag in seinen Verteilgebieten nicht mehr zu führen. Weder Verlag noch potentielle Zeitungsleser haben ein Anrecht auf Zustellung, oder? Meine Plattform, meine Regeln? Wenn ich groß genug bin, einem signifikaten Anteil der Benutzer meiner Plattform die dargebotenen Inhalte zu diktieren, kann ich ja nach Belieben die Realität formen, richtig? Nein.

Keine einigermaßen funktionierende Wirtschaft kann es sich lange erlauben, bedeutende Marktplätze unreguliert zu lassen. Aus dem Grundrecht der Berufsfreiheit in Deutschland sind diverse Einschränkung für die Märkte abgeleitet worden, um gerade kleineren und aufsteigenden Betrieben den fairen Zugang in etablierten Marktplätzen zu ermöglichen und nicht wegelagernden Kleinstfürsten wachsenden Neulingen den Saft ausquetschen zu lassen. Wenn mehrere Großbetriebe aus den USA versuchen, in Deutschland großes Geschäft zu machen, werden sie sich wohl oder übel auch an lokalen Grundrechten orientieren müssen.

Es ist meine Hoffnung, daß horizontal so breit aufgestellte Krämerläden wie Apple, Google und Amazon, die durch Disruption alter Marktstrukturen großgeworden sind, nicht nach Belieben alle "Handelsbarrieren" abbauen dürfen. Gewiß, einige Regeln müssen im Lichte neuer technischer Entwicklungen neu ausgehandelt werden. Ein Großteil dieser Barrieren sind über Jahrhunderte ausgehandelt und absichtlich etabliert worden, um den schwächeren Einzelnen vor konzentrierter nicht-staatlicher Macht zu schützen. Die durch "Marktregeln" formalisierte moralische Werte sollten gesellschaftlich ausgehandelt werden, nicht global aufgewungen. Allen sozial oder wirtschaftlich wirkenden Teilnehmern sollte Teilhabe am Markt der Ideen und Produkte gewährt werden.

In einem gar nicht so weit entfernten alternativen Zeitstrahl:

Es ist Samstag morgens. Wie gewohnt bin ich mit meiner Schubkarre zum Zeitungskiosk, um mir die Wochenendausgabe zu holen. In letzter Zeit ging es den Printmedien nicht so gut, ich weiß. Aber so langsam bin ich doch genervt.

Gut, dass die Werbeeinlagen immer mehr wurden, um den massiven Verfall der Kioskkunden und Abonnenten aufzufangen, kann ich verstehen. Guter Journalismus ist eben teuer. Klar, auch die Hochglanz-Binder in Quellekatalog-Stärke halten für mich viele interessante Produktinformationen bereit. Ein wenig zeitraubend ist das Blättern durch die auf bis zu mehreren Dutzend Werbeblätter verteilten redaktionellen Beiträge schon, sicher. Für die inzwischen mit 127 dB krakelenden Bordellwerbegrußkärtchen mit lasziven Stöhne-Aufnahmen habe ich mir so Schallschutztütchen besorgt. Wegen der Nachbarn und der Kinder. Und die kleinen schwarzen unauffälligen Beileger, wo die Stereoanlage dann immer so buppert, also diese Beileger mit den Löchlein, die angeblich Fotos von der Kreditkarte nach China schicken, da scheint die schwarze Sichtschutzfolie nicht mehr zu helfen, die ich normalerweise drumgewickelt habe. Dafür kommen die jetzt gleich mit Bleiakkus, damit die Röntgenautomatik und das Satellitenmodem genug Saft hat – daher die Schubkarre.

Nun, hier hätte ich mir schon langsam gewünscht, ich hätte den ganzen Werbekram am Kiosk in den Müll werfen dürfen. Hat aber das Beugegericht Hamburg vor fünf Jahren verboten. Gut, da konnten sie auch nicht ahnen, dass das Druckpapier der Broschüren Krebs auslösen kann und lauter Gimmicks ungefragt Bilder in alle Zimmerecken projizieren und den Sender auf der Stereoanlage verstellen können. Und immer wenn man beim Umblätter einen der um den ganzen Rand drapierten "Jetzt kostenpflichtig bestellen"-Knöpfe berührt, steht keine zwei Minuten später das Inkassounternehmen für das angelieferte und gleich wieder abgeholte Luxussofa vor der Tür.

Das passiert immer häufiger, seit der Pupillen-Tracker gleich eingebaut ist. Damit wird überprüft, ob ich auch vor dem Weiterblättern mindestens auf drei Produktinfos geschaut habe, sonst kann man ja sowieso nicht weiterlesen.

Naja, und dass einige besonders schlecht gelötete Exemplare ab und zu mal Wohnungen niederbrennen, muss man im Zweifel in Kauf nehmen, um für unsere Nachrichtenlandschaft und den unaufhaltsamen Informationsdrang des Kapitalismus das Schmiermittel bereitzustellen.

Aber das ist eben der Preis, wenn alle anderen keine Lust mehr haben, für gut recherchierte Artikel auch zu bezahlen.

In letzter Zeit ist das Belehren von Minderheiten über die Fehlerhaftigkeit ihres anachronistischen Tuns in bestimmten Communities en vogue geworden:

• Fleischlappenkonsum? – Go vegan!

• Alkoholkonsum? – Straight edga!

• Kraftfahrzeug mit Verbrennermotor? – Werde Kampfradler!

• Festanstellung? – Crowdfunded Lattetrinker!

Und dann ist da natürlich die Unsäglichkeit des Nikotinkonsums inklusive der Zwangsbeglückung der Umstehenden, der eigentlich schlimmsten Schnorrer: den Passivrauchern, die unisono ihre Überlegenheit mit passiv-aggressivem Gehuste und den heroischen Geschichten des vierwöchigen kalten Entzugs demonstrieren müssen. Auch ich huste meist. Verdeckt.

Meine Geschichte ist einfacher. Nicht so glamourös, aber nachvollziehbar. Ich war neun. Meine Mama ist Lehrer für Mathematik in mehreren Klassenstufen. Bei den unter sechzehnjährigen war es Aufgabe der als Pausenaufsicht bestimmten Lehrer, Zigarettenschachteln zu konfiszieren und für die Herausgabe an die Erziehungsberechtigten aufzubewahren. Aus diesem Grunde befand sich in der Genussmittelsektion der Schrankwand meiner Nichtraucher-Eltern eine wohlsortierte und mit Herkunftszettelchen beklebte Sammlung von Tabakwaren.

Ich war neun. Und allein zuhause. Und am Erkunden der Wohnung. Ich fand die Schachteln. An einer dieser Schachteln bediente ich mich, kombinierte die stibitzte Zigarette auf dem heimischen Balkon mit einem Streichholz und nahm einen kräftigen Zug. Nichts passierte. Ich nahm einen noch kräftigeren Zug und voller Stolz einen noch kräftigeren Zug. Immer noch nichts.

Die kolportierte Coolness des nikotinkonsumierenden Heldens klebte schon förmlich an mir, bis ich bemerkte, dass mein Streichholz nicht gezündet und ich nur massiv Nebenluft geschnorchelt hatte. Nach dem erneuten – nun erfolgreichen – Zündens meines Streichholzes erglimmte die Zigarette wirklich und mit der selben Verve wie beim letzten Kaltstart saugte ich einen saftigen Lungenzug f6 in meine unvorbereiten Bronchien, der mich instantan nach hinten umkippen ließ. Mehrere nicht näher erforschte vegetative Aussetzer des Gastrointestinaltrakt beförderten zu beiden Enden größere Mengen Materials nach außen, von denen mein Körper annahm, er könne mit dem aktuellen Unwohlsein in Zusammenhang stehen.

Mit viel zu kleinen Pupillen, Kopfschmerzen, Übelkeit und von oben bis unten besudelt mit allen erdenklichen eigenen Körperflüssigkeiten litt ich noch mehrere Stunden vor der eigenen Uncoolness kapitulierend über dem elterlichen Klobeckenrand.

Präpariert mit dieser Erfahrung erschien mir einige Jahre später die mit dem impliziten "Coolness"-Versprechen offerierte Zigarette auf dem Schulhof wie ein Hohn. Traumatisiert von den vor meinen Augen aufglimmenden Erinnerungen des gescheiterten ersten Annäherns an diese Droge fiel mir die Ablehnung unter diversen fadenscheinigen Ausreden nie schwer.

Wahrscheinlich hat mir die Erfahrung mehrere tausend Euro und diverse Lebensjahre gespart. Die Gelegenheit, am eigenen Leib einen Nikotin-Entzug durchzuziehen, hat sie mich auch gekostet. Daher werde ich weiter abstinent hüsteln. Aber nicht werten.

Im Rahmen des Symposiums "Nähe auf Distanz" des Fachbereichs Kultur an der Uni Hamburg werde ich am 14. Juni zur Wirkmacht politischer Bilder im Internet einen Vortrag mit dem Titel "Ergebnisse für Sie maßgeschneidert" halten. Abstract und Konklusio gibt es hier.

Ein Geheimdienst im 21. Jahrhundert, der was auf sich hält, muss Big Data machen: Möglichst alles über alle Bürger sammeln, horten, sortieren, filtern, rastern und ja niemandem was von den Ergebnissen mitteilen. Da hab ich mir gedacht: Das kann ich auch! Daher mache ich für meinen eigenen Kurznachrichtendienst eben in Little Big Data.

Praktischerweise stellt die Deutsche Telekom im Halbjahrestakt eine digitale Offlinedatenbank bereit, die schonmal Adressen, Telefonnummern und Geokoordinaten der meisten Einwohner enthält - und das seit 1992. Einzige Nachlässigkeit: Die Informationen sind in binärer Form auf den Datenträgern abgelegt und die Gewissenhaftigkeit der Informanten im Post- und Telekomdienst lässt ausweislich offensichtlicher Fehler in den Datensätzen zu wünschen übrig.

Von meiner Sammelleidenschaft habe ich ja bereits ausgiebig berichtet. Vor sieben Jahren war ich der festen Meinung, ich hätte alle Telefonbuch-CDs zusammen und mein Code würde alle verfügbaren Daten aus den Binärwust der Datenspender extrahieren. Doch plötzliche Funde von verschollen geglaubten Ausgaben mit noch exotischeren Formaten und die bei näherem Nachschauen auftretenden syntaktischen und semantischen Probleme in den Daten haben einen zweiten Anlauf der Pflege nötig gemacht.

Begleitet mich nun am Dienstag, dem 9. Juni 2015 ab achte im Chaos Computer Club Berlin beim Datengarten 53 in einem besinnlichen Diaabend bei Geschichten einer abenteuerlichen Jagd nach den Datensätzen, von nervenaufreibendem Starren auf Binärmuster, um den Geheimnissen der Encraption auf den Grund zu gehen und dem überwältigenden Gefühl, mal an Datenmengen zu schnuppern, die noch vor ein paar Jahren problemlos als “Big Data” durchgegangen wären.

Neulich wurde ich von Freunden gefragt, ob ich ihnen ein paar Reisetips für eine Rucksack-Tour um die Welt geben kann. Eventuell findet ihn ja noch irgendjemand nützlich, wenn er seine Reisepläne auf Plausibilität checken möchte.

Nachdem mir neulich schon das wundersame Relikt des Kirchgelds über den Wahrnehmungshorizont purzelte, mit dem sich die traurigen Reste des sich dem Laizismus wiedersetzenden Staatskirchentums ihre Pfründe auch von all denen zusammenschmarotzen, die auch nur das Leben mit einem Partner teilen, der seinen Kirchenaustritt nicht mehr belegen kann oder als EU-Bürger in Deutschland in bürokratische Hamsterräder verwickelt wird. Nach der Wende wurde arbeitslos gemeldeten Freunden gar die Kirchensteuer standardmäßig einbehalten mit dem Verweis darauf, dass eine präzise Nachforschung im Einzelfall zu hohen Aufwand bedeuten würde.

Heute nun weist mich die Sparkasse in einem Kundenschreiben auf Folgendes hin

Diese Information ist für Sie nur dann von Bedeutung, wenn sie einer
Religionsgemeinschaft angehören, für die Kirchensteuer abgezogen wird.
Sofern dies der Fall ist, führen wir für Kirchenmitglieder ab 2015 die
Kirchensteuer auf Kapitalertragsteuer automatisch an das Finanzamt ab,
sofern die Kapitalerträge oberhalb eines uns erteilten Freistellungsauf-
trages liegen, spätestens also oberhalb des gesetzlichen Sparerpauschbe-
trages (Ledige: 801 EUR, Zusammenveranlagte: 1602 EUR). Zur Vereinfachung
fragen wir Ihre Religionszugehörigkeit jährlich beim Bundeszentralamt für
Steuern (BZSt) ab.

Möchten Sie nicht, dass das BZSt uns Ihre Religionszugehörigkeit ver-
schlüsselt übermittelt, können Sie der Datenweitergabe bis zum 30.06. eines
Jahres widersprechen (www.formulare-bfinv.de,"Kirchensteuer").

Kann sich diese Sekte nicht einfach mal aus dem Leben Unbescholtener raushalten, solange diese sich nicht explizit bei denen melden? Ich zumindest will mit denen nichts zu tun haben und finde, in ihrer Geschichte haben sie genug Unheil angerichtet und könnten sich gefälligst in ihrer selbstpropagierten Demut üben. Danke.