Dienstag, 21. Januar 2020

Quantum code vividly explained: the Bernstein-Vazirani Algorithm

A brief preliminary remark: Since I have hardly found any material that approaches this algorithm from an intuitive rather than a mathematical perspective, I decided to write this post in English, as I thought it might be useful for a larger audience. If there is sufficient demand I can translate it to German later. And if happen to understand German and are an absolute beginner, you might read this post first.

On my quest to quantum computing, I approached the Bernstein-Vazirani Algorithm, which is about finding a secret bit string encoded in a box, as a first example of a "quantum supreme" algorithm. The idea is that we are not allowed to look inside the box and have to guess the number. If the box would give us simply a yes or no answer for our guesses, we would need as many attempts as there are possible combinations of bits in the worst case, which for n bits this would be 2n.

For clarification, let us consider an example where there are three bits and the secrect string is 110. We can just try to blindly guess it as follows:

 000 = 110? -> no
 001 = 110? -> no
 010 = 110? -> no
... until on the 7th try:
 110 = 110? -> yes

For the quantum algorithm example, the box is supposed to be a little more supportive as it does a bitwise AND of the secret and our guess, however, it does not simply return the result of this AND operation, but merely a single bit, which gives us the result of the AND operation summed up, with an implicit modulo 2, of course. 

Let us clarify this with another example:

 000 AND 110 = 000: 0 + 0 + 0 -> 0
 001 AND 110 = 000: 0 + 0 + 0 -> 0
 111 AND 110 = 110: 1 + 1 + 0 -> 0 (here we can see the modulo 2 at work)

Since the box each time just returns one bit, we now can find out the secret in 3 (or in the general case in n) attempts by just setting one bit after the other to 1 and accumulating the output of the box:

 100 AND 110 = 1 -> first bit must be 1 
 010 AND 110 = 1 -> middle bit must be 1
 001 AND 110 = 0 -> last bit must be 0

First Quantum Circuit
How would we build a circuit like this for a quantum computer? Unfortuntately, I find most explanations on the web either quite complicated and mathematical or so superficial that they just demonstrate the algorithm, but give no intuition how it actually works in a quantum computer. Hence, to begin with, I would first like to implement a classical solution on a quantum computer.

This is relatively simple as we can wire the secret string via CNOT gates to our output bit, measure the output bit, and try setting one after the other input bit to 1. The circuit may look as follows on the IBM Quantum Experience (in this case I tried setting q[2] to one):
Obviously (when you are fine with the basics of this notation), the result should be |1> in case of the above example, because q[2], which is set to |1>  by the X gate, triggers just one flip from |0> to |1> for q[3]:

How does it work? I think that should be easy to grasp. Everytime when there is a |1> in the secret string, we wire the according bit to the output bit. In this case, the output bit gets flipped every time when there is an actual one |1> on one of the input bits.

This gives us the desired effect of the secret box. I told you it was simple. However, we still have to do n attempts in order to find out the correct solution for the secret.

Quantum Supremacy
How can the quantum computer do better? Well, you probably have guessed it by now, we need to use superposition in order to do try all possible combinations at once and then "cheat" a bit and take a glance on all the input bits again to get the desired output after one shot.  
(This is the point where I still wonder why we are not allowed to do this in the classic case as well? just take the result of the whole AND operation?)

Starting from the circuit we had before, this is also quite simple as we would just put our input bits into superposition with Hadamard gates like so...
... and "sandwhich" them in order to reverse the superposition effect. And, of course, we also measure them afterwards:

However, this alone does not do the trick (completely). Since we are using superposition, it only delivers a correct result in about 50% of all attempts, which is of course not very helpful for just one shot. The following image illustrates that the success rate can become even worse on a real device due to the various possible errors.

A quick side note to the thoughtful reader: this should make you suspicious as the target of the CNOT gates is q[3] and not q[0], q[1], and q[2]. This is exactly the place where the quantum magic kicks in as I will explain shortly.

Fortunately, it turns out that we actually can do better than this and retrieve the result in one shot. We just need to set our output bit (usually called ancilla in this context) to |1> and bring it into superposition as well:

A quick peak into the simulator's results underlines this claim:

And even the real device delivers a pretty clear picture this time:

This is the moment where most explanations that I have found on the Web so far (and that motivated me to explain it in a more vivid way) usually drift off into linear algebra for an explanation. And as a quantum of solace to all you computer programmers who does not use this on a daily basis: You are not alone. (Although the math is actually not too bad once one understood the effects of quantum physics. It turns out, even a 17 year old girl can understand it, regadless of the math, her post is nicely readable and has a similar line of argument like mine.)

So, how does it work?
Well, how does it work? Apparently through some "quantum magic" as I hinted upon above and I will try to break it down as good as I can: First of all, we need to learn about something that is called entanglement and accept it. Entanglement means that we can have two elementary particles that are in superposition (remember: they are in |0> and |1> at the same time) entangled with each other, move them far apart from each other then, measure one of them, and instantly see the other's state being determined as well.

And if you just cannot believe me, it has been experimentally proven that this happens really instanteneously and hence "faster than light". Unfortunately, we cannot transmit any information with this "mechanism". Entanglement by the way is basically that thing that was called "spooky action at a distance" by Einstein and made him say that "god doesn't throw dice" when he digged deeper into it. I particularly like Bohr's reply to Einstein: "Stop telling god what to do!" :-) Over there at Youtube is a nice video where Philip Ball explains this phenomenon, just in case you are interested to learn more about it.

Let's get back to our quantum business, how would this help us in building a quantum computer? Well, basically, the CNOT gate with a control bit in superposition creates entanglement and this is used to get the result into our quantum circuit from above. Remember, this is exactly what we have built there: qubits in superposition connected by CNOT gates.

As I understand it, in the Bernstein-Vazirani algorithm (and many others) the target qubit (q[3] in our case) creates something like a feedback effect (called the phase kickback) on the control qubit(s), i.e. on q[1] and q[2] in our example. Let's look at the circuit again to avoid the need for scrolling around:

Although this entanglement does not change the actual value of q[1] and q[2] (as they are in superposition), it influences the pase of their wave function (I hope, I phrased this correctly as a non-physicist), which eventually forces q[1] and q[2] to collapse to a 1 as soon as they are sent through the second Hadamard gate and measured.

Examining and visualizing Kickback
We can more easily see this when we simply reduce the circuit to one control bit, which always will end up as 1 after we have run the program:

As this is probably as surprising to you as it was to me, I played around with this in Qiskit a bit more, in order to get a visual feedback for what is going on with the help of the so-called Bloch sphere. Very briefly, a Bloch sphere is a visual interpretation of a qubit. The following image shows two qubits, the left one is in |0>, which vividly is "spin down" and the right quibit is in |1>, which apparently means "spin up".

Here is the minimum code to create this image with Qiskit in a Jupyter notebook, just seven lines:

 from qiskit import *
 from qiskit.visualization import plot_bloch_multivector

 circuit = QuantumCircuit(2,2)


 statevec_simulator = Aer.get_backend("statevector_simulator")
 statevec = execute(circuit, backend=statevec_simulator).result().get_statevector()

Now let's see what happens when we put these qubits into superposition using circuit.h(0)and circuit.h(1) on them:

We can clearly see that both of them are now in a state between |0> and |1> as they have been rotated around the y axis. However, the first qubit has a positive x value now, while the second one has a negative value. (Rotate your screen counterclockwise if you find it hard to see this.)

And now (drum roll) let us try out what happens when we visualize the previous simple circuit with the phase kickback on a Bloch sphere. First, we completely rebuild it in Qiskit (don't forget the two imports from above if you want to follow along):

 circuit = QuantumCircuit(2,2)





Then, let's take a snapshot of our two qubits before each of the two barriers. The first one of course looks familiar and is not very exiting:

However, the second one is interesting, as it illustrates how the phase (i.e. the sign on the x axis) of our control qubit (on the left) has changed through the kickback from the target qubit:

If we now apply Hadamard gates to both qubits and measure, of course, both qubits will yield a 1.

This approach of playing around with the Bernstein Vazirani algorithm (inspired by this little video series) helped me to develop a vivid intuition how it might work in a real quantum computer. I hope you were able to follow along and maybe you might want to leave a thumbs comment up in this case.

Finally, a disclaimer, I am "just" a (rather practical) computer scientist and neither a mathematician nor a physicist, so if you spot any errors or have any ideas how to improve the presentation of the post, please get in touch and let me know.

After having this written, I discovered another nice video that explains Qiskit with the Bernstein-Vazirani algorithm in a quite similar fashion.

Freitag, 17. Januar 2020

In 15 min zum ersten Quantenprogramm

Obwohl Google kürzlich das Erreichen der sogenannten "Quantum Supremacy" verkündet hat, ist der Hype um den Quantencomputer aktuell noch eher überschaubar. Das mag damit zu tun haben, das zwar annähernd jeder IT-Interessierte bereits etwas über Quantencomputer gehört oder gelesen hat, wirklich verstanden haben es jedoch vermutlich die wenigsten. Vom Erstellen von Quantenprogrammen gar nicht zu reden. Wie einfach zumindest der grundlegende Einstieg in die Quatenprogrammierung in rund 10 min gelingen kann, möchte ich in diesem Post beschreiben.

Zugegeben, auch mir ging es bis vor kurzem so: mir war nicht klar, wie sich mit Qubits (Quantenbits), die 0 und 1 zur gleichen Zeit sein können, Probleme effizient lösen lassen sollen. Die meisten Erklärungen, die sich online zu diesem Thema finden, sind nämlich entweder zu oberflächlich oder gleich so mathematisch, dass es keinen Spaß mehr macht, sie nachzuvollziehen. Zudem gibt es noch recht wenige deutschsprachige Ressourcen, die vielleicht gerade bei diesem komplexen Gebiet den Einstieg erleichtern könnten (wobei natürlich jeder Informatiker auch mit Englisch klarkommen sollte).

Daher möchte ich mit diesem Blog-Post (und evtl. noch folgenden) meine persönliche Reise beim Entdecken der "Quantenrechnerei" dokumentieren und hoffentlich dem ein oder anderen Leser ein wenig das Verständnis und den Einstieg erleichtern. Hier bewegen wir uns nämlich tatsächlich im "Neuland" und können erleben, wie die Grundlagen einer Technologie geschaffen werden, die die Möglichkeiten von Computern grundlegend verändern könnte.

Als sehr hilfreich habe ich dabei empfunden, mit Quantencomputern tatsächlich zu programmieren. Moment... mit echten Quantencomputern? Sind die innendrin nicht "colder than outer space" und entsprechend super-teuer? Ja, das sind sie, und noch gibt es leider keine Quantencomputer für den Hobbykeller, doch wer ein wenig seinen Pioniergeist ausleben möchte, kann das tatsächlich: bspw. IBM bietet online einen Zugriff auf seine Quanten-Hardware an.

Das ist, wie es dieser Youtuber so schön formuliert, ein wenig so, als würde uns die NASA einen ihrer Mars-Rover steuern lassen. (Falls es letztere Idee je gegeben haben sollte, sie wurde vermutlich wegen dieses Vorfalls wieder verworfen. ;-) Daher empfiehlt es sich natürlich, einen entsprechenden Simulator (wie Qiskit) zu installieren (wie in diesem Video erklärt), um Quantenprogramme lokal testen zu können und die echten Quantencomputer nur mit sinnvollen Programmen zu behelligen.

Zum Einstieg in die Quantenprogrammierung, seien einige Hintergründe in aller Kürze erläutert. Wie bereits erwähnt, verwenden Quantencomputer sogenannte Qubits, die entweder 0 oder 1 oder auch beides zugleich sein können. Dieser letztgenannte Zustand nennt sich Superposition und ist einer der Gründe, der Quantencomputer leistungsfähiger als herkömmliche Computer machen soll. 0 bzw. 1 werden bei Qubits übrigens wie folgt in der sogenannten Dirac-Noation geschrieben: |0> bzw. |1>. Das hat damit zu tun, dass die Zustände von Qubits üblicherweise Vektoren sind, muss aber hier erst einmal nicht im Detail interessieren.

Als Qubits kommen in der Praxis verschiedene Arten von Elementarteilchen in Frage, also etwa Elektronen, Protonen oder auch Photonen. Werden bspw. Elektronen verwendet, können diese über Mikrowellen manipuliert und ausgelesen werden. Einen guten ersten Eindruck dazu vermittelt z.B. dieses Video aus Australien.

Wird ein Qubit in Superposition versetzt, also im Fall eines Elektrons mit Mikrowellen "angeregt", befindet es sich gleichzeitig sowohl im Zustand 0 als auch im Zustand 1. Sobald es ausgelesen wird, muss es sich allerdings für einen Wert entscheiden: wir erinnern uns an die bedauernswerte Katze des Herrn Schrödinger (die übrigens kürzlich tot aufgefunden wurde ;-), mit deren Hilfe sich dieses physikalische Phänomen veranschaulichen lässt. Oder auch an den Doppelspaltversuch im Physik-Unterricht, wo selbst einzelne Photonen durch beide Spalten gleichzeitig zu gehen scheinen und mit sich selbst wechselwirken können.

Wie sich auf Basis einer solchen Überlagerung programmieren lassen soll, war (und ist z.T. noch immer) für mich das erste große Fragezeichen beim Verständnis der Quantencomputer.

Grafische Programmierung in der Cloud
Doch Moment, könnten wir uns diese Unbestimmt zum Einstieg nicht einfach für etwas zunutze machen, was herkömmliche Computer nicht besonders gut beherrschen? Nämlich gerade das Erzeugen von Zufallszahlen? Mit dem folgenden Zufallszahlengenerator bei der IBM Quantum Experience möchte ich nun endlich ein erstes Quantenprogramm, und wie es auf echter Quanten-Hardware ausgeführt werden kann, beschreiben.

Nach Anmeldung und Login bei IBM klicken wir dazu auf "Create a circuit", also das Erstellen eines Quantenschaltkreises, und sollten etwa folgenden Bildschirm zu sehen bekommen:

Der rechte untere Bereich zeigt uns die aktuell zur Verfügung stehenden Qubits sowie darunter eine klassische Datenleitung, die zum Auslesen der Qubits verwendet werden kann. Die bunten Kästchen darüber sind die Quantengatter (quantum gates) mit deren Hilfe die Qubits manipuliert werden können. Und ja, hier ist echter Pioniergeist gefragt, Quantencomputer werden aktuell tatsächlich auf dem Bit- oder besser gesagt Qubit-Level programmiert.

Quantengatter sind im Prinzip sehr ähnlich zu herkömmlichen Gattern, die (wir erinnern uns) zur Verarbeitung von herkömmlichen Bits verwendet werden. Allerdings gibt es einige der gewohnten Gatter (wie AND oder OR) in der Quantenwelt erst einmal nicht. Das hat damit zu tun, dass in der Quantenwelt Qubits nicht einfach so kopiert werden könne und alle elementaren Operationen eindeutig umkehrbar sein müssen. Das bedeutet, dass aus dem Ergebnis die Eingabe wieder herstellbar sein muss, was bspw. bei OR, wo sowohl 10, 01 und auch 11 das Ergebnis 1 liefern, offensichtlich nicht der Fall ist.

Doch zurück zu unserem Zufallszahlen-Generator: für diesen müssen wir mindestens ein Quantenbit in Superposition versetzen, das geht ganz einfach z.B. mit dem sogenannten Hadamard- oder kurz auch H-Gate, das im Bild an erster Stelle der blauen Kästchen steht. Dieses ziehen wir per Drag-und-Drop auf die Linie neben einem der Qubits:
Im Bild wird also das erste Qubit q[0], das sich anfangs im Zustand |0> befindet, in Superposition versetzt (und ist nun sowohl |0> als auch |1>). Nun können wir noch das letzte schwarze Kästchen zum Messen bzw. Auslesen des Qubits auf die Linie setzten und haben damit quasi unser "Quanten-Hello-World" erstellt:

Das Messgatter legt den Wert des Quantenbits auf das entsprechende klassische Bit, dabei wird, wie bereits gesagt, die Superposition des Qubits zerstört, es muss sich fest für einen Wert (also entweder 0 oder 1) "entscheiden". Die in den Schaltkreis gesetzten Gatter können übrigens angeklickt und dann ggf. mit dem kleinen "x" in der rechten oberen Ecke wieder gelöscht werden.

Um nun unseren "Quanten-Hello-World-Moment" zu erleben (das dauert bis hierhin übrigens keine 10 min) , müssen wir noch oben rechts im Bild zunächst auf "Unsaved changes" und danach auf "Run" klicken. Sodann können wir aus einem Simulator sowie einer Reihe echter Quantencomputer das gewünschte Backend zum Ausführen wählen und angeben, wie oft das Programm ausgeführt werden soll. Da sich mit nur einer Ausführung keine Zufallsverteilung wird feststellen lassen, sollten wir hier mindestens 1024 auswählen. Einige Augenblicke später erscheint dann im unteren Fensterbereich ein Link zum Ergebnis der Berechnung:

Den Trommelwirbel müssen wir uns leider selbst dazu denken (oder hier abspielen): nach einem Klick auf den gezeigten Link finden wir im unteren Bereich der folgenden Seite in etwa das folgende Bild:

Dieses zeigt uns an, bei wie vielen der 1024 Aufrufe das Qubit q[0] zufällig mit einer 0 und bei wie vielen es mit einer 1 ausgelesen wurde. Im Bild siegt die 1 mit einem knappen Vorsprung gegenüber der 0.

Um bspw. eine Zufallszahl zwischen 0 und 7 generieren zu können, erweitern wir das Programm leicht wie folgt...

... und führen es 4096 mal auf einem der echten IBM-Quantencomputer (z.B. ibmq_ourense) aus. Das liefert uns die folgende Verteilung von Zufallszahlen (Trommelwirbel nicht vergessen):

Dabei wird q[0] ganz wie in einer normalen Darstellung eines Bit-Strings auf das am weitesten rechts stehende Bit übertragen, nicht wie die obige Anordnung der Measurement-Gates implizieren könnte, auf das am weitesten links stehende.

Mit einem Klick auf das kleine Code-Symbol am linken Rand (das </>) können wir uns übrigens auch den zugehörigen QASM-Code (Quantenassembler-Code) in Textform anzeigen lassen.

Dieser sollte mehr oder weniger selbsterklärend sein, zusammenfassend sei hier aber noch einmal der Programmaufbau beschrieben: wir legen ein Quantenregister mit 5 Qubits sowie ein klassisches Register mit 5 Bits an, versetzen die ersten drei Qubits mit dem Hadamard-Gate in Superposition und erzwingen durch jeweils eine Messung eine Festlegung der Qubits auf |0> oder |1>.

Lokal programmieren
Wer, wie im bereits genannten Video beschrieben, Qiskit installiert hat, kann ein identisches Programm auch ganz einfach lokal anlegen und ausführen: dazu müssen wir ein neues Jupyter Notebook für Python3 erstellen und folgenden Python-Code eingeben:

  from qiskit import *

  qr = QuantumRegister(3)
  cr = ClassicalRegister(3)

  circuit = QuantumCircuit(qr, cr)


  circuit.measure(qr, cr)

Ein Druck auf Shift + Return führt diesen Code-Schnipsel aus und zeichnet die drei Qubits sowie das klassische Register ähnlich zum vorherigen Bild aus dem Browser:

Ohne den Parameter beim draw-Aufruf erscheint übrigens eine ebenfalls brauchbare "ASCII-Art"-Darstellung des Quantenschaltkreises. Um das Quantenprogramm selbst ausführen zu können, wird auch lokal wieder ein Simulator benötigt, dessen Ergebnisse wir mit print ausgeben können:

  simulator = Aer.get_backend('qasm_simulator')

  result = execute(circuit, backend = simulator, shots = 1024).result()

Dies ergibt bei meinem Durchlauf folgende Ausgabe:

  {'110': 120, '000': 131, '101': 114, '111': 133, 
   '010': 120, '011': 137, '100': 130, '001': 139}
Auch ein Plotten der Ergebnisse analog zur Cloud-Variante ist mit einem weiteren Import problemlos möglich...

  from qiskit.tools.visualization import plot_histogram

...  und ergibt das folgende Bild:

Qiskit to Quantum Computer
Abschließend sei noch erläutert, wie der Aufruf des echten Quantencomputers bei IBM von Qiskit aus funktioniert (Voraussetzung ist das Hinterlegen eines Access-Tokens in Qiskit wie im Video von vorhin gezeigt), es erfordert an für sich nur den Austausch des Backends gegen einen echten Quantencomputer, wie der folgende Code-Schnipsel illustriert:

  from qiskit.tools.monitor import job_monitor

  provider = IBMQ.get_provider('ibm-q')

  qcomputer = provider.get_backend('ibmq_ourense')

  job = execute(circuit, backend = qcomputer, shots = 1024)
  result = job.result()


Der Job-Monitor wird hier genutzt, um den Status der Job-Verarbeitung angezeigt bekommen zu können, da die Verarbeitung je nach Auslastung des gewählten Quantencomputers einige Augenblicke in Anspruch nehmen kann. Hat schließlich alles erfolgreich geklappt, erhalten wir abermals ein bereits vertraut wirkendes Histogramm:

Dies gezeigten Beispiele sollten reichen, um einen ersten Eindruck und hoffentlich ein besseres initiales Verständnis der Quantenrechnerei zu bekommen, auch wenn das Generieren von Zufallszahlen noch kein wirklich hilfreicher Algorithmus war. Immerhin haben wir in aller Kürze einen Quantencomputer bei IBM grafisch "programmiert" und auch lokal über Qiskit Quantencode erstellt, der sich zudem leicht in die IBM-Cloud hochladen und dort ausführen lässt.

Ich hoffe, Sie haben auch ein wenig Geschmack an der "Zukunft der Computer" gefunden, ich jedenfalls werde versuchen, weiter in diese spannende Welt einzutauchen und, so es meine Zeit zulässt, auch noch weitere Artikel zu posten. Ich freue mich auch, Sie wieder als interessierten Leser begrüßen zu dürfen.

Weitere Ressourcen:

Freitag, 6. September 2019

Buchtipps für Informatik-Studierende und -Praktiker

Ich werde immer wieder nach guten Büchern für die Fächer, die ich unterrichte, gefragt und möchte das bevorstehende Wintersemester zum Anlass nehmen, meine ganz persönlichen Favoriten (ohne Anspruch auf Vollständigkeit) hier für alle nachlesbar mit kurzen Kommentaren aufzulisten.

Ich spare mir weitere Vorreden, here we go...

Datenmanagement & Big Data

N. Marz & J. Warren: Big Data: Principles and Best Practices of Scalable Realtime Data Systems, 2015. (bei Amazon; dt. Version)
Niemand, der mit großen Datenmengen in Berühung kommt, wird an diesem Buch und der darin beschriebenen Lambda-Architektur vorbei kommen. Es beschreibt schlicht den Backbone der Big-Data-Verarbeitung im Hadoop-Zeitalter. Durch die mit einem fortlaufenden Beispiel angereicherte Lektüre wird auch schnell klar, wie Hadoop (bzw. Map/Reduce) zum Synonym für Big Data werden und als eierlegende Wollmichsau Verwendung finden konnte. Aber Achtung, die Entwicklung gerade in diesem Bereich schreitet unheimlich schnell voran und nach Lambda kommt Kappa, nach NoSQL nun NewSQL, es bleibt also spannend. Und wer konkrete Hinweise für die Implementierung entsprechender Systeme sucht, dürfte von diesem Buch ebenfalls eher enttäuscht werden.

M. Kleppmann: Designing Data-Intensive Applications, 2017. (bei Amazon; dt. Version)
Leider gibt es bisher wenig gute Literatur im Bereich Big Data, was nicht zuletzt mit den zahlreichen Einflüssen auf dieses Feld und seine schnelle Entwicklung zurückzuführen sein dürfte. Dieses Buch ist sicher ein großer Schritt in die richtige Richtung, bringt es doch zahlreiche Themen aus den Bereichen Datenbanken und verteilte Systeme toll recherchiert zusammen. Leider hinterlässt es bei mir entsprechend ein wenig den Eindruck eines bunten Sammelsuriums und eine konkrete "Bau-Anleitung" für Big-Data-Systeme sucht man trotz des Titels vergeblich. Nichtsdestotrotz ist es gerade für ein vertiefendes Studium ein unverzichtbares Nachschlagewerk.

B. Stopford: Designing Event-Driven Systems, 2018. (freies PDF bei Confluent)
Wer in seinem Informatiker-Leben ebenfalls von der prozeduralen über die objektorientierte in der Welt der Services gelandet ist, wird sich vielleicht fragen, wie heutige Micro-Service-Architekturen und Polyglot Persistences ihre Daten koordinieren (sollen)? Kafka dürfte dafür natürlich eine naheliegende Antwort sein. Das erklärte Ziel von Confluent (der Firma hinter Kafka) ist nichts weniger als Datenbanken neu zu erfinden, indem Daten als Strom von unveränderlichen Ereignissen betrachtet werden. Zusammen mit Kafka Connect und KSQL (über das ich bereits hier geschrieben habe), ist Confluent diesem Ziel sicher einen guten Schritt näher gekommen. Dieses Buch liefert die Grundlagen und auch einige (wenige) Beispiele für diesen Ansatz und ist daher sicher ein guter Einstieg dafür. Etwas mehr Tiefgang wäre allerdings sicher nicht verkehrt gewesen.

A. Kemper & A. Eickler: Datenbanksysteme: Eine Einführung (10. Aufl.), 2015. (bei Amazon)
Datenbankbücher (für relationale Datenbanken) gibt es in etwa so viele wie Datenbanksysteme. Und wie bei den Datenbanken selbst, entscheidet wohl auch hier in erster Linie der persönliche Geschmack. Ich habe mich in meinen Vorlesungen für das Buch des Kollegen Kemper entschieden, unter anderem deshalb, weil es auch frei verfügbare Videoaufzeichnungen zu seinen Vorlesungen gibt. Ansonsten ist alles drin, was man für eine DB-Einführung braucht und noch so einiges mehr. Wie bei fast allen Büchern in diesem Bereich liegt der Fokus sehr stark SQL und auf relationalen Datenbanken, wer einen Überblick über NoSQL-Systeme sucht, sollte sich anderswo umschauen.


C. Ullenboom: Java ist auch eine Insel (14. Auflage), 2019. (bei Amazon oder die 12. Auflage kostenlos im Web
Wenn ein Buch bei Java-Buchempfehlungen nicht fehlen darf, ist es natürlich "die Insel". Das wohl umfangreichste Java-Nachschlagewerk mit vielen Erklärungen und Beispielen auf weit über 1000 Seiten. Und
gerade deshalb vielleicht für Neueinsteiger im wahrsten Sinn des Wortes zu schwere Kost. Lohnt sich aber spätestens ab dem zweiten Jahr des Programmiererlebens.

P. Deitel & H. Deitel: Java How to Program (11th Ed.), 2019. (bei Amazon)
Als ich vor rund 20 Jahren mit der Java-Programmierung begonnen habe, haben mir Deitel & Deitel bereits gute Dienste geleistet, höchste Zeit also, die elfte Auflage dieses Buches genauer unter die Lupe zu nehmen. Auf rund 1200 Seiten finden sich nach wie vor gute und umfangreiche Erklärungen zu Java mit vielen praxisorientierten Anmerkungen. Wer hier allerdings bunte Bildchen und unterhaltsame Erklärungen á la Head First Java
erwartet, wird sicherlich enttäuscht, es ist ein Lehrbuch ohne viel Schnickschnack, doch wer es schafft, es mit Disziplin durchzuarbeiten, wird mit soliden Java-Kenntnissen belohnt. Und wie es sich für eine aktualisierte Auflage gehört, sind alle wichtigen Neuerungen von Java (Lambdas, NIO, JShell, JavaFX...) mit dabei.

Hier finden Sie übrigens mein Cheat-Sheet für die prozeduralen Sprachelemente von Java.

Software Engineering

C. Larman: Applying UML and Patterns, 2004. (bei Amazon; dt. Version)
Aus meiner Sicht ohne Frage DAS Buch, wenn es darum geht, den Einstieg in die objektorientierte Software-Entwicklung zu finden. Wer schon immer wissen wollte, wie die einzelnen UML-Diagramme zusammenhängen bzw. voneinander abgeleitet werden können, ist hier an der richtigen Stelle. Agil, iterativ, kurz das Wesentliche super auf den Punkt gebracht. Besondere Stärken aus meiner Sicht sind die schrittweise Verfeinerung von Anforderungen und ihre Analyse, die Erklärung einer geschichteten Referenzarchitektur sowie das Responsibility-Driven Design.

A. Cockburn: Writing Effective Use Cases, 2000. (bei Amazon; dt. Version)
Use Cases bestehen nur aus diesen kleinen Diagrammen mit den lustigen Stichmännchen? Weit gefehlt, Use Cases bestehen aus Texten, die mit dem Benutzer hart erarbeitet werden müssen. Worauf man dabei achten sollte, damit sie als Startpunkt für eine gute Entwicklung dienen können, erklärt Cockburn in diesem Buch. Insbesondere seine Gedanken zu den "Goals Levels" sind absolut grundlegend und wichtig für jeden, der Software-Anforderungen erheben möchte; egal in welcher Form.

M. Fowler: Patterns of Enterprise Application Architecture, 2002. (bei Amazon)
Das Standardwerk zum Nachschlagen für alles was mit Software-Architektur zu tun hat. Vielleicht mittlerweile etwas in die Jahre gekommen, da hier zahlreiche neuere Trends wie Microservices und Container natürlich noch nicht enthalten sein können. Für den Einsteiger in das Thema Architektur aber definitiv nach wie vor eine Empfehlung.

E. Freeman & E. Robson: Head First Design Patterns, 2004. (bei Amazon; dt. Version)
Das Buch der Gang of Four (GoF) ist zu angestaubt und komplex für einen Einstieg in Design Patterns? Dafür schafft dieses Werk eine tolle Abhilfe und beschreibt modern und anschaulich zahlreiche (wenn auch leider nicht alle) GoF-Patterns. Den aktivierenden Schreibstil mit zahlreichen Übungen sollte man zwar mögen und sich entsprechend Zeit zum Lesen nehmen, wer aber gute Erklärungen zu den Entwurfsmustern sucht, wird an diesem Buch nicht vorbei kommen.

M. Fowler: Refactoring: Improving the Design of Existing Code (2nd ed.), 2018. (bei Amazon)
Was tun wir eigentlich, wenn die agile Entwicklung ein System nach und nach so richtig schön komplex und unübersichtlich gemacht hat? Wenn es anfängt zu stinken (engl.: code smells)? Martin Fowler mit seinem Refactoring-Buch weiß Rat und stellt zahlreiche Möglichkeiten vor, wie Sourcecode systematisch wieder aufgemöbelt werden kann. Gerade für agile Entwickler eine unverzichtbare Lektüre, die die Augen für sauberen Code neu öffnen kann.

R. Martin: Clean Code: A Handbook of Agile Software Craftsmanship, 2008. (bei Amazon; dt. Version)
Besser (als Refactoring) wäre natürlich von Anfang an ein gutes Gefühl für guten Code und die richtige Anwendung der objektorientierten Techniken zu entwickeln. Den Code sozusagen SOLIDe zu machen. Wie das geht, erklärt "Uncle Bob" in seinem Buch. Gerade für (Berufs)Einsteiger eine grundlegend wichtige Lektüre.

S. Ambler: The Object Primer: Agile Model-Driven Development with UML 2.0 (3rd ed.), 2004. (bei Amazon)
Eine schöne Ergänzung zum Buch von Larman, insbesondere, was das Thema UI-Modelling angeht, das bei Larman leider zu kurz kommt. Namensgebend für die Agile-Modelling-Bewegung und sicherlich das Lesen wert. Im direkten Vergleich für ich allerdings "den Larman" vorziehen.

O. Hummel: Aufwandsschätzungen in der Software- und Systementwicklung - kompakt, 2011. (bei Amazon)
Ein klein wenig Eigenwerbung sei an dieser Stelle erlaubt. Wer Aufwandsschätzungen für die Softwareentwicklung erstellen muss, sollte sich dieses Buch unbedingt einmal ansehen. Auch wenn ich leider ebenfalls kein Patentrezept für den Umgang mittel- und langfristigen Schätzungen in einer agilen Umgebung habe, sind doch alle grundlegendenen Schätztechniken in diesem Buch auf den Punkt gebracht. Und es wird vor den gröbsten Missbräuchen bei der Interpretation von Schätzergebnissen eindringlich gewarnt.

Zugegeben, die meisten dieser Werke fallen eher schon in die Kategorie "Klassiker", und gerade deshalb führt aus meiner Sicht für Einsteiger in die objektorientierte Entwicklung kein Weg an ihnen vorbei. Wer hier neuere Empfehlungen haben sollte oder auch weitere Klassiker vermisst, schreibe mir gerne eine Mail.


B. Christian & T. Griffiths: Algorithms to Live by - The Computer Science of Human Decisions, 2017. (bei Amazon)
Langsam aber sicher kommen auch Informatik-Themen in populärwissenschaftlichen Büchern an. Ein unterhalsames Buch, das Komplexitäts- oder Entscheidungstheorie vielleicht auch dem ein oder anderen Informatiker noch einmal etwas näher bringt. Wer schon immer einmal wissen wollte, warum es besser ist, seine Socken lieber öfter in kleinen Tranchen, statt seltener in großen Mengen zu waschen, ist hier an der richigen Stelle.

Anm.: diese Seite wird sicherlich immer mal wieder ergänzt und enthält (recht offensichtlich ;-) Werbung in Form von gesponsorten Links zu Amazon.