Debugging a GPU VM fault

Having finished debugging and fixing a rather tricky GPU VM fault bug in the radeonsi driver, I thought I'd document the bug chasing process I went through (some parts are cleaned up with dead ends removed). May it help myself and others in the future.

Fortunately, the original submitter of the bug had already bisected the cause of the VM faults to a change in LLVM, so the fault was clearly due to some shader. Unfortunately, the triggering commit in LLVM was completely unrelated to Radeon, so it was very unclear what was going on. Still, the bug occured in the publically available Unreal Elemental Demo and was easily reproducible, so off I went.

Since some shader was to blame, the first thing to do after reproduction was to collect all shaders before and after the bad commit, using RADEON_DUMP_SHADERS=y (R600_DEBUG=ps,vs,gs also does this). This resulted in a lot of output with a large diff between the good and the bad run. Clearly, the change in LLVM subtly affected register allocation and/or instruction scheduling in the compiler in a way that affected many shaders and exposed some pre-existing, underlying bug. I needed to find the exact shader that caused problems.

The next step, to ensure even more reliable and deterministic reproduction, was to record an apitrace. This allows us to replay the exact same sequence of OpenGL calls that leads to the VM faults over and over again, to learn ever more about what's going on. (The Unreal Elemental Demo always plays the same scene, but it is affected by timing.)

Now it was time to find the exact draw call that caused the problems. The driver has some tools to help with that: the GALLIUM_DDEBUG feature is meant to detect lockups, but it conveniently causes a command stream flush after every draw call, so I used it by setting GALLIUM_DDEBUG=800. This makes the replay terribly slow (there's a reason we batch many draw calls into a single CS, also called IB in the kernel). So I implemented a GALLIUM_DDEBUG_SKIP feature in the driver that let me skip the additional flushes and lockup checks for the initial, known-good segment of the trace.

In addition, the driver comes with a debug feature that detects and aborts on VM faults, which is enabled via R600_DEBUG=check_vm. Since the fault comes from a shader, we also need a way to cross-reference the dected fault to the currently bound shader. This is achieved by dumping shaders and enabling the vm debug option, for a full command line of something like

GALLIUM_DDEBUG=800 GALLIUM_DDEBUG_SKIP=170000 \
RADEON_DUMP_SHADERS=y R600_DEBUG=vm,check_vm \
glretrace -v ElementalDemo.trace > runXXX.log 2>&1

The option -v for glretrace dumps all OpenGL calls as they are executed, which also turned out to be useful.

How to find the faulty shader from all that? Well, the check_vm logic not only detects VM faults, but also writes helpful logging dumps to a file in ~/ddebug_dumps/ (use less -R to make sense of the coloring escape codes that are written to the file). Most crucially, this dump contains a list of all buffers that were mapped, obviously including the buffers that contain the shader binaries. In one example run:

        Size    VM start page         VM end page           Usage
...
         245    -- hole --
           1    0x0000000113a9b       0x0000000113a9c       USER_SHADER
         268    -- hole --
...
         564    -- hole --
           2    0x000000016f00d       0x000000016f00f       USER_SHADER
         145    -- hole --

Remember that we enabled the vm debug option together with shader dumping? This means our log contains lots of lines of the form

VM start=0x105249000  end=0x10524A000 | Buffer 4096 bytes

(Note that the log contains byte addresses, while the check_vm dump contains page numbers. Pages are 4KB, so you just need to add or remove three 0s at the end to go from bytes to pages and vice versa.) All we need to do is grep the log file for "VM start=0x113A9B" and "VM start=0x16F00D" (mmh, I'm getting hungry...). And while those might appear multiple times if a buffer is reused or destroyed, the last occurence will be where the shader binary was created.

The shader dump contains three versions of the shader: the initial TGSI, which is what Gallium's state tracker provides to the hardware-dependent driver, the LLVM IR after an initial optimization pass, and the disassembly of the final shader binary as provided by LLVM. I extracted the IR of the two shaders (vertex and fragment), and compiled them with LLVM's standalone compiler, once with the "good" version of LLVM and once with the "bad" (in both cases using the command line llc -march=amdgcn -mcpu=tonga < shader.ll). It turned out that both shaders were affected by the change, so I needed to figure out whether it was the vertex or the fragment shader.

The GUI of apitrace has the wonderful ability of allowing you to edit a trace. Remember that I used the -v option of glretrace? That produces lots of lines like

2511163 @2 glDrawRangeElements(mode = GL_TRIANGLES, start = 0, end = 9212, ...

Indeed, that was the final reported draw call, i.e. the one causing the fault. So let's open the trace with qapitrace and jump to that exact call using its number. Sure enough, not long before the call we find

glUseProgram(505)

We need to find where this program is linked, which is typically much earlier in the program. So we search for glLinkProgram(program = 505) and find exactly one such call. A short bit above, we find the calls

glAttachShader(505, 69)
glAttachShader(505, 504)

where the fragment and vertex shaders are attached to the program. Finally, we search for glShaderSource(shader = 69 and 504 to find the call where the source is loaded into the shader. Now, we can edit those calls to replace the shaders by dummy versions. Be careful, though: the length of the shader source is passed as a separate argument, and you must adjust it manually or you will get surprising error messages when running the modified trace.

By doing so, I determined that the fragment shader was at fault: even minor modifications such as re-ordering statements without changing any effects removed VM faults when applied to the fragment shader, but not when applied to the vertex shader.

So... time to stare at the disassembly of the fragment shader. Unfortunately, there was nothing that caught my eye. It was a long shader with more than 700 instructions. So what next? Since even minor changes at the source level fixed the fault, no matter what kind of change, I needed to go deeper and modify the binary directly. I wrote a new feature for radeonsi that would help me do just that, by allowing me to tell the driver to replace the binary created by LLVM on the N'th compile by a binary that is supplied as an environment variable.

I would have loved to be able to edit assembly at this point. Unfortunately, the llvm-mc tool, which can theoretically act as an assembler, is not able to parse all the assembly constructs that llc generates for the AMDGPU backend. So I went with the next best option, creating an ELF object file using llc -march=amdgcn -mcpu=tonga -filetype=obj and editing the binary directly with a hex editor.

That wasn't too bad though: since VM faults are generated by memory instructions, I could just replace those memory instructions by NOPs. Since the shader dumps collected above helpfully include the binary representation of instructions in addition to the assembly, the instructions aren't too hard to find, either. I only needed to take care not to NOP out memory instructions whose output was then later used as addresses or resource descriptors for other memory instructions, or else I would have introduced new sources for VM faults!

At that point, I ran into a tough problem. My plan was to NOP out large groups of memory instructions initially, and then do a kind of binary search to isolate the bad access. Unfortunately, what happened was, roughly speaking, that when I NOP'ed out group A of instructions or group B of instructions, the VM faults remained, but when I NOP'ed out both groups at the same time, the VM faults disappeared. This can happen when there are really two underlying bugs, but unfortunately I did not see a plausible culprit in either group (in fact, the first bug which I found was actually outside both groups, but - as far as I understand it - depended subtly on timing and on how that affected the scheduling of shader waves by the hardware).

Luckily, at that point I had long suspected the problem to be in wait state handling. You see, in order to save on complicated circuitry in the hardware, there are some rarely occuring data hazards which the compiler must avoid by inserting NOPs explicitly (there is also the s_waitcnt instruction which is part of the strategy for hiding memory latency without complex out-of-order circuitry). So I read the documentation of those hazards again and noticed that the compiler in fact didn't insert enough wait states for a sequence involving register spills (i.e., something affecting only very large shaders). I fixed that, and while it didn't eliminate the VM faults, it changed their pattern sufficiently to give me new hope.

Indeed, with the additional wait states, my original idea of finding the bad instructions by binary search was successful. I narrowed the problem down to accesses to one single texture. At that point, my brain was too exhausted to see the bug that was rather obvious in hindsight, but a colleague pointed it out to me: there was a multi-word register copy which attempted to copy a resource descriptor (consisting of 8 32-bit words) between overlapping register ranges, and it was doing that copy in the wrong direction - kind of like using memcpy when you should be using memmove.

Once this second bug was found, coming up with a fix was relatively straightforward. And yes, I checked: both bug fixes were actually required to completely fix the original bug.

That was my story. Hopefully you've learned something if you've come this far, but there is not really much of a moral to it. Perhaps it is this: pray you have deterministically reproducible bugs. If you do, patiently collecting more and more information will lead you to a solution. If you don't, well, sometimes you just have to be lucky.

Steam with radeonsi on Ubuntu 15.10 (Wily Werewolf)

For public documentation's sake, if you want to run Steam on 64-bit Ubuntu 15.10 together with the open-source radeonsi driver (the part of Mesa that implements OpenGL for recent AMD GPUs), you'll probably run into problems that can be fixed by starting Steam as

LD_PRELOAD=/usr/lib/i386-linux-gnu/libstdc++.so.6 steam

(You'll have to have installed certain 32-bit packages, which you should have automatically been prompted to do while installing Steam.)

The background of this issue is that both Steam and radeonsi contain C++ code and dynamically link against the C++ runtime libraries. However, Steam comes with its own copy of these libraries, which it prefers to link against. Meanwhile, Ubuntu 15.10 is built using the most recent g++, which contains a new C++ ABI. This ABI is not supported by the C++ libraries shipped with Steam, so that by default, the radeonsi driver fails to load due to linking errors.

The workaround noted above fixes the problem by forcing the use of the newer C++ library. (Note that it does so only for 32-bit applications. If you're running 64-bit games from Steam, a similar workaround may be required.)

OXI zu Parallelwelten

Es sind krasse Parallelwelten, die sich in Folge der Finanzkrise in Europa aufgebaut haben. Letzte Woche wurde in den Tagesthemen kommentiert, die Griechen sollten doch bitte beim gestrigen Referendum mit Ja stimmen. Die Logik des Kommentators: Dann gebe es ein Ende (der Syriza-Regierung) mit Schrecken, statt einem Schrecken (stockende Verhandlungen) ohne Ende.

Dabei erleben die Griechen den Schrecken (Rezession) ohne Ende schon seit mehreren Jahren. Folgerichtig haben sie mit deutlicher Mehrheit Nein gesagt zu den Forderungen der Gläubigern. Womöglich ist damit ein Ende (Grexit) mit Schrecken eingeleitet - so sieht es in der Welt aus, in der ich lebe, und die sich offenbar deutlich von der jenes Kommentators unterscheidet.

Der Kommentator und ich verwenden die gleiche Redensart - "Lieber ein Ende mit Schrecken als ein Schrecken ohne Ende" - und drücken damit vollkommen gegensätzliche Meinungen aus.

Das macht mir schon länger Sorgen. Denn wie überlegen haben wir uns gefühlt, als vor über 10 Jahren in den USA das öffentlich-mediale Narrativ aus dem Ruder gelaufen ist und so den Irakkrieg ermöglicht hat! Und nun passiert bei uns etwas ganz ähnliches (nur dass es wenigstens nicht in einem Krieg, sondern "nur" in der ewigen Rezession einer Volkswirtschaft durch Austeritätspolitik mündet)!

Von daher: Ganz unabhängig davon, wie es mit dem Euro weitergeht, von mir ein "Vielen Dank, ihr Griechen!" aus tiefster Seele. Denn die Griechen haben mit ihrem Mut und ihrer Standfestigkeit eine Politik gestärkt, die Europa zur Auseinandersetzung mit den blinden Flecken seiner Eliten zwingt. Die Chancen stehen besser denn je, dass wir die Parallelwelten, in denen wir leben, aufbrechen und wieder gemeinsam zur Vernunft finden können.

Kritik an der Struktur des Europäischen Emissionshandels

Die Reduktion von Treibhausgasemissionen ist ein (überlebens-)wichtiges Politikziel. Ein Mechanismus dafür unter vielen ist der Emissionshandel in der EU.

Der funktioniert so: Emittenten kaufen das Recht, Treibhausgase auszustoßen. Konkret kaufen sie ein standardisiertes Finanzprodukt, das kurz "allowance" genannt wird. Eine Allowance erlaubt den Ausstoß einer Tonne CO₂ (bzw. einer äquivalenten Menge anderer Treibhausgase). Einmal im Jahr wird abgerechnet, wie viel der Emittent im vorangegangenen Jahr tatsächlich ausgestoßen hat. Die entsprechende Anzahl an Allowances muss er abgeben. Diese Allowances werden vernichtet und sind nicht mehr verfügbar. Hat der Emittent nicht genügend Allowances, muss er eine Strafe zahlen.

Die Allowances können wie Aktien an der Börse gehandelt werden, und wir wissen, wie sie vernichtet werden. Aber wie kommen sie in Umlauf? Es gibt eine politisch definierte Menge an Allowances, die jährlich in der EU in Umlauf gebracht wird (für 2015 sind es knapp über 20 Mrd. im Emissionsmarkt für "power stations and other fixed installations"; es gibt einen separaten Markt für Flugemissionen, aber solche Details klammere ich aus). Zum einen erhalten Emittenten kostenlos Allowances je nach Industrie und Unternehmensgröße. Dieser erste Mechanismus ist primär dazu gedacht, die Einführung des Emissionshandels möglichst reibungsfrei zu gestalten, und verliert im Laufe der Zeit an Bedeutung. Die restlichen Allowances werden durch die Mitgliedsstaaten per regelmäßiger Auktion verkauft, mindestens die Hälfte der Erlöse muss für Projekte im Rahmen des Klimawandels verwendet werden. Der Lebenszyklus der Allowances sieht also so aus:

Eine Allowance kostet übrigens zur Zeit zwischen 7€ und 8€. So weit die grobe Übersicht.

Eine politisch aufgeladene Frage ist natürlich noch, wer überhaupt Allowances kaufen muss, um Treibhausgase auszustoßen. Als Normalbürger darf man schließlich das eigene Haus heizen und Auto fahren, ohne sich am Emissionshandel zu beteiligen, und auch nicht alle Industrien sind gleichermaßen betroffen. Aber hier will ich mich konkreten Fragen der Marktstruktur zuwenden. Ich habe dazu einen kleinen und einen sehr großen Kritikpunkt.

1. Die relevante Regulierung legt fest (Artikel 6), dass jedes Gebot auf Auktionen ein Vielfaches von 500 oder 1000 Allowances sein muss. Insbesondere ist damit ein relativ hohes Mindestgebot festgelegt. Erstens erhöht dies die Hürden, überhaupt an Auktionen teilzunehmen. Zweitens wird es für Auktionsteilnehmer schwieriger, ihre Nachfragekurve präzise als Gebote zu formulieren. Und all das ohne guten Grund: Die Handelssysteme funktionieren allesamt elektronisch, und die Auktionen arbeiten im Stundentakt. Es wäre also problemlos möglich, Auktionen mit der feinsten Auflösung durchzuführen.
   
   
2. Die harte Festlegung auf eine bestimmte Emissionsmenge pro Jahr ist weltfremd. Natürlich hat die verwendete Technologie eine Auswirkung auf die Emissionsmenge, und das Umrüsten auf umweltfreundlichere Produktionsmethoden ist ja gerade ein Ziel der Politik des Emissionshandels. Allerdings sind diese Umstellungsprozesse sehr langfristig. Kurzfristig wird die Emissionsmenge primär durch die Wirtschaftsleistung bestimmt, also durch die Nachfrage nach Produkten. Diese wird sich nur wegen des bisschen Emissionshandels nicht ändern.
   
   Folgerichtig wird in einem Jahr also nie genau die politisch bestimmte angepeilte Menge emittiert, sondern entweder zu viel oder zu wenig. Wird zu viel emittiert, dann reicht die Menge der zufließenden Allowances nicht aus, um die tatsächlichen Emissionen abzudecken. Es werden also zwangsläufig irgendwo Strafen gezahlt werden müssen, was den Preis der Allowances in die Höhe treibt, bis eine Allowance genausoviel kostet wie die ansonsten zu zahlende Strafe.
   
   Wird "zu wenig" emittiert, dann gibt es ein Überangebot an Allowances, was den Preis auf 0 drückt. Tatsächlich ist das auch zwischendurch in der Geschichte des Emissionshandels geschehen.
   
   Graphisch gezeigt verhält sich der Preis für Allowances in etwa wie folgt, wobei M die angestrebte Emissionsmenge und S die Strafe für eine fehlende Allowance ist:
   
   
   
   
   Bei perfekter Voraussicht der Marktteilnehmer müsste die Preiskurve bei M sogar vertikal sein. Praktisch ist diese perfekte Voraussicht nicht gegeben, so dass sich eine weniger langweilige Kurve ergibt. Dennoch ist vollkommen unklar, ob die resultierende Kurve irgendeine sinnvolle Erkenntnis wiedergibt. Wahrscheinlicher ist, dass sie wie ein Fraktal im Wesentlichen chaotisch und zufällig aus Implementierungsdetails des Marktes entsteht, und der tatsächliche Informationsgehalt verschwindend gering ist.

Was lernen wir daraus? Zunächst einmal lernen wir, dass Märkte nur begrenzten Nutzen haben, wenn eine Seite des Marktes (in diesem Fall der Erzeuger von Allowances) de facto aus nur einem Teilnehmer besteht. Prinzipiell wäre zwar denkbar, dass Treibhausgas-Senken - also Projekte, die CO₂ langfristig aus der Atmosphäre ziehen - auch als Verkäufer von Allowances am Markt teilnehmen könnten, aber dagegen gibt es aus anderen Gründen berechtigte Bedenken.

Die potentiell drastischen Preisschwankungen bei Fehleinschätzung der tatsächlichen Emissionsmenge wurden bereits als Problem erkannt. Was dagegen getan werden kann ist mir aber unklar. Es gibt durchaus Alternativen zum Emissionshandel, um eine Einpreisung der Emissionen zu erzwingen, ganz banal zum Beispiel eine Emissionssteuer.

Wenn man beim Emissionshandel bleiben möchte - vielleicht auch im Hinblick darauf, dass dieser langfristig am ehesten international durchsetzbar ist - könnte die EU-Kommission statt der Emissionsmenge die Preiskurve fixieren. Vom aktuellen Auktionsmodell müsste man sich verabschieden. Konkret könnte die Kommission jederzeit zum Verkauf von Allowances bereitstehen, wobei der Preis vom gleitenden durchschnittlichen Verkaufsvolumen der letzten X Tage abhängt. Auf diese Weise ließe sich eine Preiskurve realisieren, die so aussieht:

Anstatt die in Auktionen verfügbaren Emissionsmengen schrittweise zu reduzieren, würde die Kommission dann diese Kurve im Laufe der Jahre nach links verschieben. Vermutlich hat auch diese Variante ihre Schwächen, aber sie müsste die Planungsunsicherheit eliminieren, die mit drastisch schwankenden Preisen verbunden ist. Insgesamt habe ich den Eindruck, dass wir auf diesem Gebiet noch viel Erfahrung sammeln müssen.

Interesting mistakes

I taught a course in Linear and Integer Optimization last semester, the exam of which was held last week. I'm fairly pleased with the results. Grading an exam is often painful when you realize that some students failed to understand important concepts, but overall it appears that my expectations about the difficulty of this exam were mostly accurate. Sometimes, however, students fail at a problem for reasons that we do not anticipate. One problem of the exam was to prove that when P and Q are (convex) polytopes, then so is their Minkowski sum P + Q.

I am aware of two reasonable approaches to this problem. The first is to use inequality representations to argue that the product P x Q is a polyhedron, and then appeal to the fact (shown in the lecture) that the image under the linear map (p, q) -> p + q is a polyhedron (boundedness is of course easy to see, and naturally there are some variations of this approach). The second approach is to use representations of P and Q as convex hulls of finitely many points, and to show that P + Q is the convex hull of the pairwise sum of such points. This second proof is elementary but requires a bit more work because one has to argue about the coefficients in convex combinations.

To my surprise, several students attempted a third route. They started with inequality representations and used the boundedness to argue that given one of the inequalities ax <= b that define P, the maximum of ax over Q is finite. They then tried to prove that P + Q can be obtained by simply using both the inequalities defining P and those defining Q together, with the right-hand sides increased by the corresponding (finite) maximum over the other polytope. This approach cannot possibly work because the number of facets of the Minkowski sum can be exponentially larger than the number of facets of the summands (the permutahedron is a cute example of this). And yet, in hindsight, it is a very plausible approach to try if one doesn't know about this fact.

As mistakes go, I would call this an interesting mistake. In some sense it isn't even a mistake at all, just a false trail into the woods that unfortunately some students got lost in.

Katharsis durch geschriebene und nicht abgeschickte Kommentare

Das ist schon fast jedem passiert: Man liest den Online-Kommentar irgendeines unbekannten Fremden, den man für furchtbaren Unfug hält. Unbedingt muss man ihn oder sie verbessern! So füllen sich die Kommentar-Bereiche von Blogs, und es werden Monster wie die Foren von Spiegel Online geschaffen.

Ich schließe mich da nicht aus. Auf Blogs, die ich regelmäßig lese, treibt sich die ein oder andere dort schon gut bekannte Person herum, mit der ich überhaupt nicht auf einen Nenner komme. Unsere größte Gemeinsamkeit, zumindest der ausgetauschten Kommentare nach zu urteilen, ist, dass wir zu viel Zeit auf Blogs verbringen.

Am besten wäre es, das alles zu ignorieren. Manchmal geht das auch, aber immer wieder kommt es vor, dass ein Kommentar an mir nagt, wenn mal wieder jemand etwas (für mich...) Offensichtliches nicht verstanden hat oder - und das ist oft wahrscheinlicher - nicht verstehen will. Dann ertappe ich mich dabei, zumindest einen kurzen Kommentar zu schreiben, der eine nutzlose Diskussion nur noch weiter verlängert. Es tut gut, in einer solchen Situation inne zu halten, kurz die Augen zu schließen, und den begonnenen Kommentar einfach wieder zu löschen, bevor er meinen Computer verlässt.

Danach fühle ich mich gut - und obwohl der Kommentar letztlich nicht abgeschickt wurde ist das nagende Gefühl, das ein gänzlich unbeantworteter Kommentar ausgelöst hat, verschwunden. Gleichzeitig ist die Diskussion beendet, so dass Zeit und zukünftige nagende Gefühle gespart werden.

Meistens ist das die beste Lösung. Es ist ziemlich irrational und unlogisch, aber so ist die Psyche nun mal. Ich kann die Strategie daher nur weiterempfehlen.

In der Schweiz Erwähnenswertes

Als ich letztes Wochenende aus Oberwolfach zurück gefahren bin, musste ich mit ein paar Kollegen in Offenburg auf den Anschlusszug warten. Dort hatte die Bahn einen Aushang, auf dem Sonderzüge zu einem sogenannten "Basler Morgestraich" angekündigt wurden.

Neugierig und mit intelligenten Telefonen bewaffnet haben wir also den Wikipedia-Artikel gelesen, den ich für die geneigte Leserin hier nicht kopieren muss. Aber wir haben doch gestutzt, dass der Bericht über die falsch gestellte Uhr, wegen der der Morgestraich im Jahr 2002 eine Minute zu früh gestartet ist, fast 10% des Artikels ausmacht. Was manche Menschen eben so bewegt...

The tone of Linus Torvalds

Linus Torvalds is known for verbally ruffling feathers. I was reminded of this once more when a thread about a workaround for a bug in rarely used graphics cards caught my eye.

There's no disagreement going on - unlike in the more famous examples of Linus Torvalds ripping into a person who he disagrees with (usually rightfully, and on solid technical grounds). And yet, pay attention to Dave Airlie's emails. From my past involvement in Mesa3D for the Radeon drivers, I know Dave a little bit, as a kind and friendly person. After the mail of Linus Torvalds, his tone changes significantly, using "crap" twice in a very gratuitous way.

The situation here isn't hostile at all, and yet the language becomes hostile after the supreme alpha geek enters the ring and the others begin to ape his style.

Of course, Linus Torvalds regularly defends this style by saying that it ensures that his message really gets through instead of being dampened by layers of friendly fluff, which he considers to be noise that distracts from the signal. There's truth in that. And yet, here we have evidence that the tone of discussion becomes unwelcoming even when all of the participants are on the same page. This is bound to create an unnecessary rise in serotonin levels at least in some people, which is bound to cause losses to the project.

So is this style really necessary to successfully run a large scale open source project? The answer appears to be No, given how many other projects exist, and how few of them create the kind of noise about their internal conduct as the Linux kernel does.

I do find it interesting to observe that there is possibly no other person in a comparable situation to Linus Torvalds, simply by virtue of how the development of the Linux kernel is structured. Even though he has delegated most of the work, all changes to the Linux kernel eventually must pass through him, as he is the only person who can change the project's master branch. Compare this to other large open source projects, all of which (to my knowledge) allow their master branch to be written to by a group of core developers. It seems to me that there is a curious feedback loop going on between Linus Torvalds' character and the environment he operates in.

Preismechanismus + Ungleichheit = Suboptimal

Märkte - eigentlich genauer: frei bewegliche Preise - sind eine schöne Sache für die Organisation von produktiver Kooperation. Aber Märkte führen nicht immer zu optimalen Ergebnissen. Ich möchte das am Beispiel von Vielleicht-Taxi-Unternehmen wie Uber, Lyft, und so weiter, die sich nicht an die Tarife des regulären Taxigewerbes binden möchten, illustrieren (und stehle damit ganz schamlos vom exzellenten Matt Bruenig, der kein mir bekanntes Pendant im deutschen Sprachraum hat).

Sagen die Ökonomen nicht, dass freie Märkte optimal sind? Nein. Das kann so pauschal auch gar nicht sein, denn "optimal" ist immer relativ zu einer Bemessungsgrundlage. Wer glaubt, dass freie Märkte optimal sind, macht damit also automatisch eine subjektive Wertung.

Was die Ökonomen sagen ist, dass flexible Preise und ein freier Markt markträumend sind. Der Umsatz wird laut Ökonomen maximiert: Damit sich zusätzliche Käufer finden, müsste der Preis sinken, und damit sich zusätzliche Verkäufer finden, müsste der Preis steigen. Ökonomen zeichnen dazu Diagramme, die so aussehen:

Die Ökonomen sagen, dass die Menschen auf Preis-Signal aus ihrer Außenwelt reagieren, also: "Das Produkt kostet X; zu diesem Preis kaufe ich Y". Außerhalb der Parallelwelt der Ökonomen wird die abhängige Variable auf der vertikalen Achse gezeichnet, weshalb es vielleicht einfacher ist, das Diagramm richtig herum zu zeichnen:

Eine zentrale Annahme fließt in das Diagramm mit hinein: Bei steigendem Preis finden sich mehr potentielle Verkäufer, aber weniger potentielle Käufer. Das ist im Allgemeinen natürlich falsch, weshalb dieses einfache Bild auch zurecht kritisiert wird. Für viele Märkte ist es aber ungefähr richtig, so auch bei den Vielleicht-Taxis, die mir als Beispiel dienen.

Aus dieser und weiteren Annahmen (z.B. dass es die gezeichneten Kurven überhaupt gibt) folgt, dass es (genau) einen Preis gibt, zu dem sich die Angebots- und die Nachfragemenge gleichen. Würde man den Preis auf einen anderen Wert festlegen (zum Beispiel per Gesetz), so würde eine geringere Menge umgesetzt, weil entweder die Angebotsmenge unter der Nachfragemenge liegt oder umgekehrt.

Unter gewissen, oft auch plausiblen Annahmen maximiert ein freier Markt also die umgesetzte Menge. Aber ist das auch optimal?

Die Frage der Zielfunktion

Um diese Frage zu beantworten muss man zuerst einmal wissen, was die Gesellschaft eigentlich erreichen will. Das ist gar nicht so einfach. Grundlage für einen Kompromiss ist sicher die Feststellung, dass die Lebensqualität der Menschen wichtig ist. Ökonomen würden von individuellen Nutzenfunktionen reden. Menschen, die durch eine Kombination von Egoismus und entweder Reichtum oder Naivität geprägt sind, würden vermutlich die Summe dieser Nutzenfunktionen maximieren wollen. Menschen, die die Argumente von Rawls und anderen überzeugend finden, würden vermutlich eher erreichen wollen, dass die minimale Lebensqualität maximal wird. Und natürlich gibt es eine weite Bandbreite dazwischen.

Vor diesem Hintergrund möchte ich das Beispiel der Vielleicht-Taxi-Unternehmen untersuchen. Diese argumentieren, dass sie das Angebot an Vielleicht-Taxis erhöhen, wenn sie zu Stoßzeiten oder zu besonderen Krisenanlässen die Preise erhöhen, und dass dadurch ein für die Gesellschaft besseres Ergebnis erzielt wird als durch klassische Taxis mit festen Tarifen. Dass Letzteres im Allgemeinen falsch ist will ich an einem Beispiel illustrieren.

Sagen wir, dass sich am Beispiel-Ort (Taxingen) zur Beispiel-Zeit (2 Uhr dienstags morgens) das Angebot und die Nachfrage nach Taxi-Diensten so eingependelt hat, dass normalerweise 10 Leute eine Fahrt nachfragen und von 10 Fahrern auch bedient werden.

Jetzt kommt die Katastrophe: Vielleicht ein Unwetter, in dessen Folge plötzlich 100 Leute um diese Zeit eine Fahrt nachfragen. Nehmen wir einmal an, dass es im klassischen Taxi-Gewerbe trotzdem noch nur 10 Fahrer gibt (weil ja, der simplen Ökonomen-Logik folgend, nur der gleichbleibende Preis das Angebot bestimmt). Welche der 100 Leute erhalten die 10 Fahrten? Wer einmal in einer solchen Situation war weiß, dass es ziemlich viel mit Zufall zu tun hat.

Im Gegensatz dazu würden die Vielleicht-Taxi-Unternehmen ihre Preise anheben. Nehmen wir einmal an, dass sich dabei der Marktpreis findet (was natürlich nicht stimmt, weil auch diese Unternehmen letztlich Preise zentral steuern - aber wir können gerne so tun, als ob). Sagen wir, dass sie auf diese Weise 10 zusätzliche Fahrer auf die Straße locken können (was schon viel ist, wenn doch die Fahrer sicher auch mit dem Unwetter zu kämpfen haben...). Von den 100 Leuten, die ursprünglich eine Fahrt nachgefragt hätten, halten sich wegen des hohen Preises 80 zurück, so dass auf 20 Fahrer genau 20 verbleibende Kunden kommen. Der Markt ist geräumt, und eine größere Zahl an Fahrten hat stattgefunden.

Welche der 100 Leute erhalten die 20 Fahrten? Die 20, die bereit sind, am meisten Geld dafür zu bieten. Jetzt kommt Ungleichheit ins Spiel. Wenn alle 100 Leute gleich vermögend wären, dann könnten wir davon ausgehen, dass diejenigen, die am meisten Geld für die Fahrt bieten, auch den größten Nutzen davon erzielen. Damit wäre die Summe des Nutzens der 20 Taxifahrten auf jeden Fall größer als der erwartete Nutzen der 10 zufälligen Taxifahrten bei festen Preisen. Wenn Vermögensgleichheit herrschen würde, wäre das Ergebnis also tatsächlich besser.

Ungleichheit entkoppelt Nutzen von Geldwert

Wir leben in einer ungleichen Welt. Ein Beamter im gehobenen Dienst wird 80 Euro für eine nächtliche Taxifahrt, die sonst nur 8 Euro kostet, weg stecken können - eine auf 400 Euro-Basis angestellte Hilfskraft eher nicht, obwohl diese Hilfskraft vielleicht einen höheren Nutzen durch die Fahrt erzielen würde.

Mit dem Preismechanismus erhält besagte Hilfskraft die Fahrt garantiert nicht; ohne den Preismechanismus hat sie wenigstens eine Chance. Es ist durchaus denkbar, dass der erwartete Nutzen bei den 10 zufälligen Fahrten höher ist als bei den 20 Fahrten, die an die Meistbietenden gehen. Das erklärt übrigens auch, weshalb es gerade für ärmere Menschen durchaus rational sein kann, gegen Marktmechanismen zu sein.

Für die Verfechter von freien Märkten ergibt sich eine Zwickmühle. Entweder, sie wollen die finanzielle Ungleichheit, die sich aus ungezügelten Märkten ergibt, beibehalten. Dann müssen sie in Kauf nehmen, dass Märkte eben nicht immer die beste Antwort auf gesellschaftliche Fragen sind. Oder sie wollen die Gesellschaft wirklich marktwirtschaftlich organisieren - aber dann müssen sie in Kauf nehmen, dass aktiv gegen finanzielle Ungleichheit vorgegangen wird. Wer für die Gesellschaft optimale Institutionen will, der muss einen Kompromiss suchen.

Realistisch gesehen ist das gerade den radikalen Verfechtern von freien Märkten - Mitglieder einer gewissen neuerdings trichromen Partei, zum Beispiel - natürlich alles egal. Ihnen geht es nicht darum, gesellschaftlich optimale Institutionen zu schaffen. Sie sind einfach Überzeugungstäter, oder nur an der eigenen privilegierten Position interessiert, oder beides.

Noch mehr Spaghetti! Wie soll Staatsfinanzierung durch die EZB aussehen?

Im Freitag erscheint ein Artikel von Christian Felber mit dem etwas albernen Titel "Mehr Spaghetti für die Wirtschaft". Der Artikel handelt nicht etwa von Griechenland, wie man angesichts des aktuellen, etwas ermüdenden Dauerthemas erwarten könnte, sondern von der EZB-Politik des Quantitative Easings. Der geneigte Leser sollte ihn am besten jetzt sofort lesen. Dieses Blog hier wartet solange geduldig.

Es stimmt vollkommen, dass die Staatsfinanzierung über Finanzmärkte ein unsinniges, undemokratisches Konstrukt ist. Der Vorschlag von Christian Felber, Staatsanleihen bis zur Höhe von 50% des BIP direkt und ohne Zinsen von der EZB kaufen zu lassen ist gut und richtig. Ich würde aber noch einen Schritt weiter gehen.

Woher kommt eigentlich diese Zahl von 50%? Mit den 50% ist es genau wie mit den fast schon in Vergessenheit geratenen 60% aus dem Vertrag von Maastricht oder den durch Reinhart und Rogoff popularisierten 90%. Diese Zahlen sind aus der Luft gegriffen. In Vergessenheit gerät dabei, dass Keynes für eine expansive Fiskalpolitik plädiert hat, als der Schuldenstand weit oberhalb von 100% zum BIP lag. Was ist also die richtige Zahl?

Es gibt keine, und zwar aus gutem Grund. Die wesentliche und notwendige Funktion von Staatsschulden ist die des Gegengewichts zu privaten Vermögen. Private Haushalte versuchen aus den verschiedensten und meist auch berechtigten Gründen, direkt oder indirekt Vermögen aufzubauen. Das schafft finanzielle Freiheit, sorgt vor fürs Alter, und so weiter. Dieses Vermögen kann zum Beispiel in Form eines Eigenheims oder in Form von Anteilen an privaten Unternehmen gehalten werden. Insgesamt gibt es aber nie genügend Werte - und vor allem nicht genügend Werte der gewünschten Bonität - um die "Nachfrage" nach Vermögen zu bedienen (das ist keine mathematisch zwingende Tatsache, sondern eine empirische Beobachtung). Ohne Staatsschulden führt diese "Nachfrage" nach Vermögen zu einem Sparverhalten, das die Nachfrage nach Gütern und Dienstleistungen drückt und dadurch die Wirtschaft abwürgt. Staatsschulden dienen als Ausgleichsventil, weil sie einen Vermögenswert guter Bonität zur Verfügung stellen.

Wie viele Staatsschulden werden für diese Funktion als Ausgleichsventil benötigt? Das hängt vom Sparverhalten der privaten Haushalte und vom Verhalten der privaten Wirtschaft ab. Deshalb ist eine feste Zahl Unsinn - egal ob man sie nun auf 50%, 60%, 90%, oder gar 200% setzt. Die Aufgabe der Politik muss es sein, angemessen auf das Verhalten des Privatsektors zu reagieren.

Für die Eurozone bedeutet das, dass die EZB Staatsfinanzierung nicht nur bis zu einer festen Grenze leisten sollte, sondern - den Umständen entsprechend - potentiell unbegrenzt. Natürlich darf der Zugriff auf diese Finanzierung nicht nur von der Politik der individuellen Mitgliedsstaaten abhängig sein, da sonst einer Inflationsspirale nichts im Weg stünde (das ist offensichtlich und wurde auch schon von Christian Felber angemerkt). Außerdem gibt es noch das Problem der Fairness: Wenn Österreich aus guten Gründen ordentlich bei der EZB zugreift, dann werden die Populisten in Deutschland darauf pochen, dass das unfair ist und man zumindest genauso zugreifen sollte - auch wenn es in Deutschland vielleicht gar keinen ökonomisch angemessenen Grund dafür gibt. Dann werden Geschenke verteilt, die man bald wieder rückgängig machen muss.

Meine favorisierte Lösung ist daher, dass man ein System fester Grenzen, wie es von Christian Felber vorgeschlagen wird, durch automatische Stabilisatoren ergänzt, die einheitlich für die Eurozone sind. Der progressivste Vorschlag in diese Richtung ist eine Euro-weite Job-Garantie. Es wäre aber auch denkbar, verschiedene Sozialsysteme, wie zum Beispiel eine Arbeitslosigkeitsversicherung, auf Ebene der Eurozone zu errichten und durch die EZB abzusichern (die Sozialsysteme der einzelnen Mitgliedsstaaten würden natürlich - entsprechend reduziert - als Ergänzung weitergeführt). Der Vorteil liegt auf der Hand: Wenn in der nächsten Krise die Arbeitslosigkeit wieder in die Höhe schnellt, und staatliche Ausgaben am dringendsten benötigt werden, dann wird der größte Teil dieser Last durch die Eurozone insgesamt getragen. Einzelne Staaten geraten nicht mehr in einen fiskalischen Teufelskreis, und eine humanitäre Katastrophe, wie wir sie jetzt in Griechenland erlebt haben, kann auf gerechte Weise vermieden werden.

My first ever patch for GDB

I have recently started contributing to KDevelop, my favorite free software IDE, effectively taking over maintainership of the GDB plugin. In the course of this work, I noticed a rather silly little thing in GDB.

Unfortunately, the current "Launch Configuration" dialog in KDevelop makes it rather easy to accidentally set a directory as the name of the executable to be launched. That's a whole issue in itself which needs to be addressed at some point. For now, my attention was caught by the following, rather self-contradictory error message:

(For the non-German-speakers: "Erfolg" means "success".) It turns out that this is not KDevelop's fault, as the second part of the error message is generated by GDB itself. So I dug into the sources to GDB, which I had lying around anyway, and was able to find and fix the cause of the confusion without too much effort. The result is bug #17911 and its attachment. It's a trivial patch, but it feels good anyway. Now it'll have to be picked up by some of the maintainers...

Fun with references and bitfields in C++

Do you know C++ well? Then you'll surely know what this piece of code does:

#include <iostream>

struct Bitfields {
    unsigned int a : 3;
    unsigned int b : 29;
};

int main()
{
    Bitfields b;
    b.a = 2;
    b.b = 3;
    const unsigned int& r = b.a;
    std::cout << sizeof(Bitfields) << ' ' << r << std::endl;
    b.a = 4;
    std::cout << r << std::endl;
}

Go ahead, try it. A few days ago I would still have been convinced that this doesn't even compile. Then a student of mine ran into a problem with bitfields, and in tracking the problem down, we found out that it does - but with a surprising twist.

This is a story about one of the dark corners of C++.

Bitfields are a convenient feature. When you want to run a graph algorithm like Dijkstra and its extensions on a graph with tens of millions or even billions of nodes, reducing your node data structures from, say, 24 bytes to 16 bytes is a big deal. Sometimes this is possible because that 8-bit char really only needs 3 bits, and together with alignment issues these kind of savings can add up. Bitfields are convenient syntax for what one would otherwise have to do manually using bit shifts and masking operations.

Unfortunately, bitfields don't compose very well with other language features. For example, they don't have a byte-level address, so you cannot take pointers to them. Since you cannot take pointers to them, you cannot take references to them.

Wait, hold on, you can. But only const references. And what happens then is completely at odds with how references to variables work everywhere else in C++: a temporary object of the underlying non-bitfield type is allocated and initialized with the value of the bitfield. The reference then refers to that temporary. What?!

Once you recover from the shock, a perfectly plausible and sane story explains this insane behavior. Bitfields don't compose well with the rest of the language. This could be changed. The type system could be extended to cover bit fields properly. References to a bitfield of type unsigned int:7 could be represented as a pointer plus a bit-shift offset. Everything would make perfect theoretical sense... except that bitfields are only rarely used, and in mostly-C-looking code. They are already one of the premier sources of compiler bugs, and making everything involving a rarely-used feature like bitfields more complex is probably not going to help. Hence there isn't much interest in complicating things just to integrate bitfields properly. That's a perfectly reasonable and pragmatic decision to make.

Except that with generic programming and templates, a common pattern is that functions take const T& parameters - including functions like std::max, which one would very plausibly want to use with a value from a bitfield. If you cannot take references to bitfields, that's not possible - and that would become really annoying really quickly for the people who actually do use bitfields. So a pragmatic compromise is made: the bitfield value is copied to a temporary, and a reference to that temporary is passed to the function.

In fact, one might think of this as a special case of what happens when you combine an implicit type conversion with the fact that const references can bind to temporary return values of functions. Consider the following sample program:

#include <iostream>

struct Ops {
    unsigned int a;

    operator unsigned int() const {return a;}
};

int main()
{
    Ops o;
    o.a = 11;
    const unsigned int& s = o;
    std::cout << s << std::endl;
    o.a = 4;
    std::cout << s << std::endl;
}

This program prints 11 twice, because s ends up being bound to the temporary object that is returned by the custom type conversion operator. In 99% of all cases, this is exactly what you want, and suddenly, the behavior seems downright logical - except that when you see only the first example program above, printing the same number twice is a pretty crazy outcome.

I actually like C++ as a language. I think it occupies an important part of the design space for languages, and especially with the more recent developments, it does so quite well - but it definitely has its share of weirdness. The saving grace is that there is a reasonable story for why it behaves the way it does, and while the outcome is a bit crazy, it doesn't actually matter much in practice - unlike, say, JavaScript's Array.prototype.sort.

Thoughts on the HoloLens

Last week, Microsoft publicly announced their take on augmented reality, the HoloLens. Some people are already complaining about the technically incorrect use of the term "holographic", but certainly the ostensibly live demo is impressive. The combination of an augmented reality display with Kinect-style gesture recognition could be a significant step further towards the non-dystopic part of a Minority Report-like future.

There is one important technical issue though that I'm worried the Microsoft marketing machine may be trying to bury. Think about how the visual system works: it's all about photons arriving in your eye at the right time in the right place. Usually, those photons are reflections off objects in the world around us. Augmented reality of the type that Microsoft claims to have built here must allow a mixture of such reflected photons and photons that are generated by a process similar to computer screens and projectors.

Here's the thing: All existing augmented reality systems are additive in terms of brightness. They always let the real-world photons through, and add their own augmented-reality photons to do their thing. This means, for example, that this type of system cannot show black text on a white (real-world) wall. It also means that augmented-reality objects appear transparent.

The demo video pretends that the augmented-reality objects are (or can be) opaque, but keep in mind that you're looking at a rendered simulation. What you see in the video is not really what the AR user is seeing, even though the presenter claims that it is. The fact that the "visor" of the systems appears so dark could also hint at a "solution" which simply decides to make the real world quite dark, so that the augmented-reality objects can stand out better.

Now the laws of physics allow one to build a "perfect" AR system that can show opaque objects. It requires building a lens that can filter the real-world photons out selectively, on a per-pixel basis. This kind of technology isn't crazy science-fiction; after all, we can manipulate matter on a nanometer scale. It's just that as far as I know, nobody has built such a thing yet, and if Microsoft have done so, then why are they so quiet about this issue in their announcement?

So who knows. Maybe I missed something in the announcement. For now, I'm skeptical.

Sado-Maso Europolitik

(Dieser Kommentar ist auch als Gastbeitrag auf Deliberation Daily erschienen.)

Anlässlich des Wahlergebnisses in Griechenland schreibt Stefan Sasse einen klugen Kommentar, in dem er unter anderem den wichtigen Hinweis gibt:

Die Belastungen, denen die Griechen ausgesetzt sind, sind in einer Demokratie auf die Dauer nicht zu ertragen, und für die Griechen gehen sie mittlerweile in die Halbzeit einer Dekade. Den Deutschen reichten seinerzeit zweieinhalb Jahre unter solchen wirtschaftlichen Bedingungen, um alle Demokraten zum Teufel zu wünschen und ihr Glück im Autoritarismus zu suchen.

Davor aber schreibt er:

Das BIP des Landes ist gewaltig eingebrochen, und mit ihm die Gehälter, Löhne und Sozialleistungen, auf denen der bisherige griechische Lebensstandard fußte. Man mag dies wie die meisten Staaten der Europäischen Union, Deutschland voran, als eine ökonomisch notwendige und schmerzhafte Anpassungsoperation sehen, an deren Ende ein gesundes Griechenland den Kampf um wirtschaftlichen Wohlstand erneut aufnehmen kann. In der Realität aber ist die Frage, ob diese Sicht richtig ist – die an dieser Stelle auch nicht beantwortet werden kann – völlig irrelevant.

Ich kann verstehen, dass Stefan dieses Fass an dieser Stelle nicht aufmachen wollte, aber die Frage ist alles andere als irrelevant. Wenn wir aus der ersten großen Wirtschaftskrise der Eurozone lernen wollen, müssen wir diese Frage richtig beantworten.

Da gibt es keinen Zweifel: Die deutsche Mainstream-Position ist gefährlicher, quasi-religiöser, und sadistisch-masochistischer Unfug.

Das ist drastisch formuliert, aber auf mehreren Ebenen gut begründbar. Zunächst ist die Position quasi-religiös: sie fußt nicht auf sauberer volkswirtschaftlicher Analyse, sondern auf dem unreflektierten Glauben an die Lehren der schwäbischen Hausfrau, die aber makroökonomisch nicht anwendbar sind. Ja, es gibt deutsche Ökonomen - auch akademischer Couleur - die im deutschen Mainstream schwimmen. International sind diese Ökonomen ziemlich isoliert.

Stefan hat bereits erklärt, wieso die Position gefährlich ist - siehe das Zitat eingangs.

Vor allem aber ist die Position Unfug, nämlich sachlich falsch. Es gibt Situationen, in denen ein Land tatsächlich wirtschaftlich schwierige Zeiten durchleben muss. Aber solche Situationen sehen anders aus, und können von Demokratien auch gut überlebt werden. Man denke zum Beispiel an Großbritannien oder die USA im Zweiten Weltkrieg. Die Anstrengungen des Krieges hatten drastische wirtschaftliche Konsequenzen, und die Menschen mussten tatsächlich "ihre Gürtel enger schnallen". Aber da waren die Gründe für jeden klar erkennbar, weshalb daraus keine Probe für die Demokratie wurde. Und, was auch noch auffallen sollte: es gab keine Arbeitslosigkeit. Im Gegenteil: wer immer irgendwie wirtschaftlich oder militärisch einsetzbar war wurde eingesetzt.

Warum konnte die Arbeitslosigkeit in Griechenland über 25% steigen? Es ist offensichtlich, dass es den Menschen in Griechenland besser ginge, wenn dort mehr Menschen arbeiten und daher mehr produziert würde. Tatsächlich ist Arbeitslosigkeit immer Verschwendung und nie zwangsläufig notwendig.

Wenn Griechenland 2009 aus dem Euro ausgetreten wäre, dann stünde das Land heute zweifellos deutlich besser da. Das lehren uns die historischen Erfahrungen, die vor dem Zweiten Weltkrieg mit der Aufgabe des Goldstandards gemacht wurden - der Austritt aus dem Euro wäre analog dazu. Ja, eine wieder eingeführte Drachme, oder wie auch immer die neue von Griechenland ausgegebene Währung dann genannt würde, hätte zunächst deutlich an Wert verloren. Aber gleichzeitig hätte die griechische Regierung die Handlungsfreiheit gehabt, um Vollbeschäftigung zu erreichen. Die Wirtschaft wäre wieder besser gelaufen, und eine Wirtschaft, die gut läuft, ist gleichzeitig eine flexiblere und anpassungsfähigere Wirtschaft.

Wenn ich Alexis Tsipras wäre, würde ich deshalb auch den griechischen Austritt als "nukleare Option" auf dem Verhandlungstisch belassen. Langfristig gesehen braucht Griechenland den Euro nicht wirklich. Aber die Eurozone braucht Griechenland als Mitglied, um langfristig zu überleben: ein "Grexit" würde in der nächsten Krise Nachahmer finden.

Wir stellen also fest: das griechische Leid ist unnötig, wenn man bereit ist, den Euro aufzugeben. Damit ist die deutsche Position sachlich falsch. Aber was, wenn man den Euro beibehalten will?

Die deutsche Position basiert auf einem Fünkchen Wahrheit. Wenn die relative Produktivität, insbesondere gemessen als Marktwert der produzierten Güter dividiert durch dafür gezahlte Gehälter und Löhne, zwischen zwei Ländern verschieden ist, dann führt dies mittelfristig zu einem Ungleichgewicht im Handel zwischen diesen Ländern. Wenn die Länder verschiedene Währung verwenden, dann führt dieses Ungleichgewicht zu einer Verschiebung des Wechselkurses, so dass sich die relative Produktivität und damit der Handel wieder ausgleicht.

Innerhalb der Eurozone gibt es keine Wechselkurse, so dass sich die Handelsströme nicht automatisch ausgleichen. Den Handelsströmen stehen in der Bilanz Geldströme gegenüber, so dass sich das (relativ gemessen) unproduktivere Land auf Dauer verschuldet.

In den meisten ähnlich gestrickten Situationen wird politisch ein direkter Ausgleich geschaffen, so zum Beispiel innerhalb Deutschlands ganz explizit durch den Länderfinanzausgleich. Es gibt aber auch einen impliziten Ausgleich durch die Steuern und Ausgaben der Bundesregierung, die einen signifikanten Teil der Wirtschaftsleistung ausmachen.

Zwischen Griechenland und dem Rest der Eurozone gibt es keinen direkten Ausgleich dieser Form. Die einzige Alternative wäre also ein Angleichen der relativen Produktivität. Hier behauptet die deutsche Position, dass dies nur möglich ist, indem die Löhne und Gehälter in Griechenland jahrelang nicht steigen oder sogar fallen. Das ist offensichtlich falsch, denn schließlich könnten die Löhne und Gehälter auch einfach in Deutschland (und einigen anderen Ländern) einige Jahre lang deutlich schneller steigen.

tl;dr: Die deutsche Position basiert auf den Irrglauben,

1. dass der Ausgleich in relativer Produktivität durch griechisches Leid und Lohndumping geschehen muss anstatt durch Belohnung deutscher und anderer Arbeiter und Angestellter (weshalb ich die deutsche Position sadistisch-masochistisch nenne), und
2. dass irgendein Währungsraum der Welt langfristig ohne politische Finanzausgleiche (egal ob explizit oder implizit) funktionieren könnte.

Ausländische Investitionen

Syriza hat die Wahlen in Griechenland mit deutlichem Abstand gewonnen. Typisch für der Herren eigener Geist, in dem sich unsere heutige Zeit spiegelt, sorgen sich die Verfechter der marktkonformen Demokratie um die verschiedenen wirtschaftlichen Konsequenzen des Wahlergebnisses. Zum Beispiel: Sieht es für ausländische Investitionen in Griechenland jetzt düster aus? Ich möchte dies als Anlass für ein paar grundsätzliche Überlegungen nehmen.

Lauscht man den Sonntagsreden der Politiker, dann gehört die Steigerung der Attraktivität des eigenen Landes für ausländische Investoren zu den wichtigsten Tugenden einer Regierung. Zeit für die Frage nach des Kaisers neuen Kleidern: Warum eigentlich?

Die oberflächlichen Argumente sind einfach: Da kommt jemand, stellt eine Fabrik o.ä. hin, und das schafft Arbeitsplätze. So weit richtig, sofern man mal von den vielen Beispielen der Enttäuschung absieht, in denen ein ausländisches Unternehmen mit zeitlich beschränkten Steuergeschenken angelockt wird. Wenn diese Geschenke dann auslaufen sind alle furchtbar überrascht, wenn sich das Unternehmen wieder verabschiedet.

Aber selbst wenn die Investoren bleiben, so bleiben sie nur, wenn und weil sie einen dauerhaften Profit darin sehen. Aus der Perspektive des Auslands sieht das super aus: Man schickt eine einmalige Geldsumme, und erhält anschließend einen potentiell ewig anhaltenden Geldstrom, ohne, dass man dafür eine Gegenleistung bieten muss. Dies ist schließlich das Wesen allen Profits und aller Kapitalerträge.

Dementsprechend schlecht sieht der Deal für das Land aus, in dem die Investition getätigt wird: Klar, am Anfang kommt da eine Geldsumme herein, und klar, da werden Arbeitsplätze geschaffen. Aber gleichzeitig verpflichtet sich das Land dazu, potentiell auf ewig einen Geldstrom ins Ausland zu schicken, ohne dafür eine Gegenleistung zu erhalten.

Auf einmal sehen ausländische Investitionen überhaupt nicht mehr so toll aus.

Es wird noch schlimmer: Braucht man die ausländischen Investitionen überhaupt, um die Arbeitsplätze zu schaffen? In vielen Fällen nein. Das nötige Geld für den Aufbau der Fabrik o.ä. kann auch im Inland zum Beispiel durch den Finanzsektor bereitgestellt werden. Die gleiche Produktion kann oft gewährleistet werden, ohne dass danach langfristig Geld ins Ausland fließt. Schlimmstenfalls fließen die gleichen Ströme an reiche Inländer, bestenfalls in Pensionsfonds oder in einen Staatsfonds à la Norwegen oder Alaska.

Ein schönes Beispiel für all diese Überlegungen ist die Ausbeutung Rohstoff-reicher armer Länder. Dort kommen ausländische Investoren und bauen Minen. Sie entziehen dem Land die Bodenschätze, aber die Gewinne kassieren Ausländer. Dabei könnten diese Länder prinzipiell die gleichen Minen selbst bauen. Sicherlich müssten sie anfänglich notwendige Maschinen aus dem Ausland kaufen - aber die langfristigen Gewinne würden sie selbst einkassieren. Es wäre genau das umgekehrte Bild: eine einmalige Geldsumme wurde anfänglich ans Ausland gehen, damit ein langfristiger Geldstrom an Gewinnen aus dem Ausland aufgebaut wird. Das sieht kurzfristig teuer aus, ist aber langfristig der intelligentere Weg. Manche Regierungen verstehen das auch.

Das Beispiel der Maschinen, zu deren Bau das technische Know-How zumindest anfänglich nicht im Inland verfügbar ist, zeigt auch, dass ausländische Investitionen unter bestimmten Umständen ein akzeptabler Kompromiss sein können. Zum Beispiel eben dann, wenn das organisatorische Know-How im Inland nicht verfügbar ist, und dafür gesorgt wird, dass diese Know-How im Zuge der Investition langsam aufgebaut wird. Letzteres zu garantieren ist aber ein extrem schwieriges Spiel mit dem Feuer.

Die Idee, sich für ausländische Investitionen attraktiv machen zu wollen, ist fehlgeleitet. Das heißt nicht, dass man sich abschotten muss. Es heißt erst recht nicht, dass man auf internationalen Handel verzichten sollte - das ist eine andere Geschichte. Aber es heißt eben, dass es besser für ein Land ist, wenn es Investitionen aus sich selbst heraus generiert. Daran sollte sich Politik orientieren.

Use .kateconfig for setting per-project indentation and tab settings in Kate

Everybody who has ever worked with source code knows: proper indentation is vital to keeping your sanity.

However, people cannot seem to agree on whether to use tabs or spaces (and if the latter, how many spaces) to use for indentation. This is unfortunate, because the obviously correct way of doing it is with tabs. The only reason why many people believe spaces are superior is because

1. they want their indentation to look shorter than 8 fixed-width characters, the tab-width was not configurable back in the computing stone age, and people in general are incredibly conservative; and
2. they fundamentally misunderstand the difference between indentation and alignment, and generally overuse alignment.

Having contributed my part to the eternal flame war, even more important than using tabs for indentation is having a consistent style within each project.

So what is a user of the Kate editor (like myself, who uses it as part of KDevelop) to do when faced with working in different projects with different styles? I recently discovered a feature of Kate that is not documented widely enough: It will search the full hierarchy of parent directories for a file named .kateconfig. So just put a .kateconfig file in the root directory of each project you're working on, containing a single line like the following:

kate: space-indent off; indent-width 4; replace-tabs off; tab-width 4; indent-mode cstyle;

And voilà, you're good to go!