Veröffentlicht am

ChatGPT for Agile Software Development – Boost or Risk?

ChatGPT sample code generation dialog

Agile software development is a widely adopted methodology that emphasizes flexibility, collaboration, and iterative progress. As software engineers strive to optimize their workflow, the use of ChatGPT can offer numerous benefits to enhance their agility. However, it is important to be mindful of potential risks that could hinder the agile process. Let’s explore both the advantages and potential pitfalls of incorporating ChatGPT into agile software development.

Ways ChatGPT Could Help

There are some ways ChatGPT could help software engineers be more Agile:

    1. Improved Communication: Effective communication is a cornerstone of agile development, and ChatGPT can facilitate this by providing real-time feedback and suggestions during team discussions. It can analyze code snippets, offer syntax recommendations, and even assist in identifying potential vulnerabilities. This could streamline the development process and fostering collaboration among team members.
    2. Rapid Prototyping: ChatGPT can aid in generating code snippets and prototypes, which can accelerate the development of minimum viable products (MVPs). This allows software engineers to quickly iterate and gather feedback from stakeholders. Doing so could lead to faster decision-making and validation of ideas, a core principle of agile development.
    3. Enhanced Documentation: Documentation is vital in Agile development to maintain transparency and knowledge sharing among team members. ChatGPT can assist in generating documentation templates, code comments, and other technical write-ups, saving valuable time and effort, and ensuring that project documentation remains up-to-date and accessible to all team members.

But… where there is light there is shadow.

Dangers to Agile Development with ChatGPT

A few points com to mind, when we want to highlight the risks:

    1. Over-reliance on Automation: Relying solely on ChatGPT for code generation and suggestions can potentially lead to a decrease in critical thinking and creativity among software engineers. Agile development values the human element, and excessive reliance on automation could result in a loss of innovation and diversity of ideas, which are essential for creating robust and unique solutions.
    2. Quality Control Challenges: While ChatGPT can provide suggestions for code snippets, it may not always guarantee the best practices or optimal solutions. If not thoroughly reviewed and validated, code generated by ChatGPT could potentially introduce bugs, security vulnerabilities, or violate coding standards. This may result in increased technical debt and rework, contradicting the principles of Agile development.
    3. Ethical Considerations: As a language model, ChatGPT can potentially generate biased or unethical code, especially when trained on biased data. This could result in unintentional propagation of bias or unethical practices in the software being developed, which could have ethical, legal, and reputational consequences, posing a risk to the integrity and fairness of Agile development.

Mitigating the Risks

There are though some things we can do to mitigate the risks:

    1. Strike a Balance: Software engineers should strike a balance between utilizing ChatGPT as a tool for assistance and leveraging their own expertise and creativity. It is essential to maintain critical thinking, innovation, and human decision-making in the agile development process.
    2. Validate Generated Code: Code generated by ChatGPT should be thoroughly reviewed, validated, and tested to ensure it adheres to coding standards, follows best practices, and meets quality requirements. This includes thorough testing, code reviews, and validation against project specifications to identify and fix any potential issues before deploying the code.
    3. Ethical Considerations: Be mindful of the ethical implications of using ChatGPT in software development. Training data should be diverse, inclusive, and free from bias. Review the code generated by ChatGPT for any potential biases or unethical practices, and take necessary steps to mitigate them. It’s important to have a strong ethical framework and guidelines in place when incorporating ChatGPT into the Agile development process.

An Experiment

My personal (admittedly still limited) experience using ChatGPT to generate and explain code confirms the risks associated using the tool (at least in its current state).

Actually, when using it intensely and double checking its output, one can still see its limits.

The code it generates looks mostly clean, but it does not follow a specific coding style. Actually the temperature setting of the ChatGPT dialogue engine is set to give “creative” answers. So you will get different variants on how you could implement an idea. If you have no personal idea on how a solution should look like you can go with any proposed code. But if you try to stick to a specific coding style, you oftentimes find yourself second-guessing what it proposes.

How far ChatGPT’s understanding of the code goes can be easily challenged doing these few steps:

    1. Let it generate some code (for a problem domain, you might be familiar with).
      → I let it generate code to calculate the distance between two planets at any point in time.
    2. It usually gives a verbal explanation on what the code does.
      → It explained to me, that it was using a Euclidean formula to calculate the distance.
    3. Then modify the generated code slightly (like a programmer would do, when moving it to an IDE and evolving it over time).
      → I just changed the calculation of the Euclidean formula slightly.
    4. Paste the modified version of the code back into ChatGPT and ask it to explain the code.
      → ChatGPT explained to me that the code used the Euclidean formula. But this could not be true, as I changed the formula to be invalid.


Just this little experiment shows the danger of relying too much on ChatGPT’s help, at least in its current state. There actually is no reasoning behind what it spits out. Unfortunately for many people that do not take its output with a grain of salt its convincing authoritative tone will produce lots of non valid output.

So yes, validating, testing and questioning its output is essential. We as developers need to step up our game, by knowing what the expected results should be, before asking ChatGPT. So Agile development skills will be in high demand more than ever before.

In the coming weeks I will have a look at various practices from Agile software development (like test automation, evolutionary software design, etc. ) and how they are impacted by the use of artificial intelligence tools.

If you are interested in improving your Agile implementation, then check out my upcoming book.

Note: My experiments were done using ChatGPT version 3.5. As soon as I can get my hands on ChatGPT 4 I will do a follow-up to this post.


The Practitioner’s Handbook will appear in Spring 2023

Aagile Practitioner Handbook

Be informed and join the waiting list:

Please type your eMail and confirm
Veröffentlicht am

Python-Einzeiler mit for und if

Python One-Liner mit for und if

Python-Einzeiler mit for und if

Einzeiler – oder One Liner – sind pure Python-Magie. Hier ein Beispiel:

[print(x * '*') for x in range(1, 5)]

Der Code produziert folgendes:


Wir könnten auch schreiben:

for x in range(1, 5):
    print(x * '*')

Allgemeine Regel für One Liner

Die allgemeine Regel lautet wie folgt:

[Ausdruck Kontext]

Der Python-Interpreter erwartet die eckigen Klammern, um den Einzeiler überhaupt zu erkennen.

Ausdruck engl. Expression

Ein Ausdruck (engl. Expression) ist in der Programmierung ein Konstrukt, das ausgewertet werden kann, um dessen Wert zu bestimmen. Es besteht aus Konstanten, Variablen, Funktionen, Operatoren.


x + 3
wert == True
print(‘Hello World’)
print(3 * ‘x’)


Der Kontext gibt die Werte an, auf die der Ausdruck angewendet werden soll. Hier können beliebig viele for und if-Statements stehen.

[print(x * '*') for x in range(1, 5) if x % 2 == 0]

Der Output sieht so aus:



Zuerst wird also range(1, 5) erzeugt und auf die resultierende Folge wird noch x % 2 == 0 angewendet.

Die Langform lautet wie folgt:

for x in range(1, 5):
   if (x % 2 == 0):
       print(x * '*')

Anmerkung: Dazu wäre die if-Anweisung nicht nötig, wir könnten ja auch sagen range(2,5,2) – doch hier geht es um Einzeiler.

Verschachtelte Listen als einen Einzeiler

Das können wir noch weiter treiben:

[print(x, y) for x in range(3) for y in range(2)]

Probier aus auf dem Python Playground direkt im Browser.

Hier haben wir zwei verschachtelte Listen. Hier die aufgelöste Form:

for x in range(3):
   for y in range(2):
       print(x, y)

Einzeiler mit for und if

Der Phantasie sind keine Grenzen gesetzt:

[print(x, y) for x in range(3) if x % 2 == 0 for y in range(2)]

Hier werden die geraden x ausgewählt. Und jetzt wählen wir noch die ungeraden y und erhalten:

[print(x, y) for x in range(3) if x % 2 == 0 for y in range(2) if y % 2 == 1]

Hier die Langform: Statt einer Zeile benötigt sie ganze fünf Zeilen:

for x in range(3):
   if x % 2 == 0:
       for y in range(2):
           if y % 2 == 1:
               print(x, y)

Ergebnis eines One-Liners als Variable

Sterne ausgeben ist immer hübsch, aber in Wirklichkeit eher nutzlos. Hier eine praktische Einsatzmöglichkeit:

v = [(x,y) for x in range(3) if x % 2 == 0 for y in range(2) if y % 2 == 1]

v ist also eine Liste von Tupeln, deren Inhalt den genannten Bedingungen genügt. Ganz schön praktisch für viele Anwendungen.

Python Datentypen

Der Einsatz von Einzeilern setzt gute Kenntnisse der eingebauten Datentypen von Python voraus.
Hol dir unser Cheat Sheet – Alle Built-In Python Datentypen auf einen Blick:

Veröffentlicht am Schreib einen Kommentar

Bubble Sort: Einen Algorithmus entwickeln

Algorithmus Enwicklen am Beispiel von Bubble Sort

Bubble Sort Algorithmus entwickeln

Wir entwickeln den Bubble Sort Algorithmus. Wir abstrahieren den intuitiven Ansatz mit Pseudocode und Aktivitätendiagram, implementieren in Python und Java und schließen ab mit der Laufzeitbetrachtung.

Dieses Schrittweise Vorgehen können wir für jede Art von Algorithmus anwenden. Oft liegt die Lösung ja nicht auf der Hand und wir tasten uns heran. Der Artikel zeigt, wie das geht.

Autorin: Ursula Deriu


Intuitiver Ansatz

Der intuitive Ansatz wird oft auch “naiv” ganannt. Das ist nicht abwertend gemeint, sondern bezeichnet den ersten Ansatz eines Algorithmus, der den meiste Leuten auf anhieb einfällt. Ausgehend von diesem naiven Ansatz wird der Algorithmus optimiert – oft ein langer Weg.

Hol dir auch das kostenlose E-Booklet über die Grundlagen der Algorithmen-Entwicklung. Dort werden die Elemente detailliert dargestellt und du findest noch mehr Übungsbeispiele.

Wir entwickeln den Bubble Sort. Dieser gilt als naiver Ansatz – also intuitiv fassbar – um beispielsweise Spielkarten zu sortieren. Am besten holst du ein paar Spielkarten oder etwas Vergleichbars, das du sortieren kannst.

Beobachte dich selbst:

  • Lege die Karten in einer beliebigen Reihenfolge auf den Tisch.
  • Sortiere sie, so wie du das immer machst.

Wie gehst du vor? Welches ist dein Verfahren? Beschreibe es mit einfachen Worten, so ähnlich wie wenn du eine Anleitung zum Karten sortieren schreiben würdest.

Bubble Sort zum Spielkarten sortieren

Wir haben ein kurzes Video gedreht, das zeigt, wie Spielkarten mit dem Bubbe Sort sortiert werden. Klick auf das +-Zeichen und schau dir das Video an.

Video Bubble Sort

Kannst du den Algorithmus des Bubble-Sort erkennen? Beschreibe ihn mit eigenen Worten.

Bubble Sort im Pseudocode

Pseudocode ist eine leicht formalisierte aber nicht standardisierte Art, um einen Algorithmus aufzuschreiben. Schreibe Pseudocode noch bevor du den Code in einer Programmiersprache aufschreibst. So gelingt es dir, Ordnung in die Gedanken zu schaffen und Strukturen zu erkennen. Mehr Beispiele in Pseudocode findest du im E-Booklet Grundlagen Algorithmen.

Klick aufs +-Zeichen und untersuche den Pseudocode zum Bubble Sort.

Beispiel Pseudocode für Bubble Sort

Der Einfachheit halber nummerieren wir die Schritte.

Die Einrückungen machen den Pseudocode übersichtlicher.

01 Wiederhole den folgenden Vorgang, bis du in einem Durchlauf von Schritt 02 bis 08 keine Vertauschung vornehmen musst:

02   Beginne links.

03   Wiederhole den folgenden Vorgang für die ganze Kartenreihe:

04     Vergleiche zwei nebeneinander liegende Karten.

05     Ist der Wert der Karte links größer als der Wert der Karte rechts?

06       dann vertausche die beiden Karten

07     betrachte die nächsten beiden Karten

08     fahre weiter bei Schritt 04

Erkennst du den Vorgang aus dem Video wieder?

Versuche mit Hilfe dieses Pseudocodes deine Spielkarten zu sortieren.

Bubble Sort als Aktivitätendiagramm

Das Aktivitätendiagramm ist eine Alternative zum Bubble-Sort. Beide Hilfsmittel dienen dazu, einen Algorithmus zu formulieren noch bevor wir diesen in einer Progammiersprache codieren.

Klicke erneut auf das +-Zeichen und untersuche das Aktivitätendiagramm zum Bubble Sort.

Beispiel Aktivitätendiagramm für Bubble Sort

Aktivitätendiagramme oder Flowcharts, sind eine weitere Möglichkeit, um eine Idee für einen Algorithmus zu skizzieren. Papier, Bleistift und Radiergummi sind völlig ausreichend.Bubblseort Aktivitätendiagramm

Versuche mit Hilfe des Aktivitätendiagramms deine Spielkarten zu sortieren.

Bubble Sort in Python

Haben wir den Algorithmus als Pseudocode oder Aktivitätendiagramm entwickelt, dann wollen wir diesen in einer Programmiersprache implementieren.

Wir nehmen hier Python – du kannst den Code auch gleich ausprobieren auf dem Python Playground.

Beispiel Python Code für Bubble Sort

Erinnere: Einrückungen sind in Python ein wichtiges Sprachelement. Wir haben auch im Pseudocode damit gearbeitet.

Wir können den Algorithmus schrittweise entwickeln. Das Vorgehen kannst du mit einer beliebigen Sprache nachvollziehen.

Zuerst benötigen wir eine geeignete Datenstruktur. Wir nehmen eine Python-Liste.

Und wir benötigen die Möglichkeit, auf ein einzelnes Element in der Liste mit Hilfe eines Indexes zuzugreifen.

Mit der Python-Funktion len() bestimmen wir die Länge der Liste. So können wir bestimmen, ob wir “ganz rechts” angelangt sind.

Das folgende Code-Snippet zeigt diese Python-Sprachelemente. Wir geben jedes Element der Liste auf einer Zeile aus.

liste = [6 ,5, 4, 3, 2, 1]
length = len(liste)
for i in range(length):

Die Liste im Beispiel ist absteigend sortiert – wir wollen sie jetzt aufsteigend sortieren. Du kannst auch mit einer völlig unsortierten Liste testen. Vergiss die negativen Zahlen nicht, auch diese sollten korrekt behandelt werden.

Als erstes implementieren wir einen Durchlauf: Wir durchlaufen die Liste einmal und nehmen die notwendigen Vertauschungen vor. Das Vertauschen von Variablen funktioniert in Python besonders einfach. Die Hintergründe dazu erfährst du im Blog Post über Variablen tauschen in Java und Python. Dort siehst du auch, wie in anderen Sprachen Elemente vertauscht werden.

Hier das Code-Snipped für einen Durchgang. Wir wollen ja immer benachbarte Elemente vergleichen. Die Variable i0 hilft dabei. Wir müssen darauf achten, sie rechtzeitig nachzuführen.

liste = [6 ,5, 4, 3, 2, 1]
i0 = 0
for i in range(1, length):
  if (liste[i0] > liste[i]):
    (liste[i0], liste[i]) = (liste[i], liste[i0])
    i0 = i

Hast du den Code im Python Playground ausgeführt? Hast du bemerkt, wie die 6 von links nach rechts wandert und schon nach einem Durchlauf am Ende steht. Wie eine kleine Blase wandert die Vertauschung durch die Liste und von da kommt auch der Name des Algorithmus.

Jetzt wiederholen wir den Vorgang so lange, bis keine Variable mehr vertauscht wird. Dazu benötigen wir einen Merker. Wir nennen diese Variable swapped – immerhin bedeuted vertauschen im englischen ja swap. Wir merken uns also, ob in einem Durchlauf geswappt wurde.

Beachte im Code Snippet wo diese Variable verändert wird. Auch die Variable i0 muss korrekt nachgeführt werden.


liste = [6 ,5, 4, 3, 2, 1]
length = len(liste)
swapped = True
while swapped == True:
  i0 = 0
  swapped = False
  for i in range(1, length):
    if (liste[i0] > liste[i]):
      (liste[i0], liste[i]) = (liste[i], liste[i0])
      swapped = True
    i0 = i

Sortieren ist so wichtig und so oft verwendet, dass die allermeisten Programmiersprachen bereits einen guten Sortieralgorithmus mitbringen.

Zwei Varianten in Python:

Sortieren in Python als Methode

liste = [6 ,5, 4, 3, 2, 1]

Sortieren in Python als Funktion

liste2 = sorted(liste)

Der Unterschied – die Funktion liefert eine neue Liste zurück – die unsortierte Liste bleibt erhalten. Die Methode sortiert die Liste in sich.

Bubble Sort in Java

Wir können den Algorithmus ja ein einer beliebigen Programmiersprache implementieren. Es folgt ein Beispiel in Java. Der Code ist Eins-zu-Eins aus Python übersetzt. Klicke aufs +-Zeichen und vergleiche mit dem Python-Code.

Beispiel Java Code für Bubble Sort

Java ist eine typsichere Sprache – wir müssen also immer den Datentyp definieren.

Eine einfache Möglichkeit, den Inhalt des Arrays anzuzeigen müssen wir uns ebenfalls selbst schaffen – hier mit Hilfe der Methode print().

Variablen vertauschen geht auch nicht so elegant wie in Python – wir könnten statt der drei Zeilen auch eine weitere Methode schreiben, z.B. swap()

class BubbleSort {
  public static void main(String[] args) {
    int[] liste = {6, 5, 4, 3, 2, 1} ;
    int length = liste.length;
    boolean swapped = true;
    while (swapped) {
    int i0 = 0;
    swapped = false;
    for (int i = 1; i < length; i++) {
      if (liste[i0] > liste[i]) {
        int hilfsfeld = liste[i0];
        liste[i0] = liste[i];
        liste[i] = hilfsfeld;
        swapped = true;
      i0 = i;
  private static void print(int[] liste) {
    for (int i=0; i<liste.length; i++) {
      System.out.print(" "+liste[i]);

Laufzeitverhalten des Bubble Sort

Hast du bemerkt, wie oft ein Vergleich vorgenommen wird?

Wir haben 6 Elemente in der Liste und es wurden 36 Vergleiche vorgenommen. Wir haben ja pro Vergleich ein print() programmiert. Wir hätten auch einen Zähler mitführen können.

Man sagt, dass das Laufzeitverhalten des Bubble Sort O(n*n) ist – als quadratisch in Bezug auf die Anzahl Elemente in der Liste. Das ist ein denkbar schlechtes Laufzeitverhalten. Man bemerkt es, wenn große Listen sortiert werden.

Der Bubble Sort ist ja auch der naive Ansatz zum Sortieren. Es wurde viel geforscht und eine ganze Reihe optimierter Algorithmen wurden entwickelt.

Sie schnellsten Sorts haben ein Laufzeitverhalten von beispielsweise O(n log(n)).

Weitere Sortieralgorithmen

Es eine ganze Reihe von Sortier-Algorithmen. Diese haben unterschiedliche Eigenschaften und jeder hat einen Namen.

  • Bubble-Sort
  • Shaker Sort
  • Selection Sort
  • Insertion Sort
  • Heap Sort
  • Quick Sort
  • Merge Sort
  • Shell Sort
  • Radix Sort

Die Verfahren sind unterschiedlich schnell und verbrauchen unterschiedlich viel Speicherplatz. Einige davon sind ganz schön raffiniert, wie beispielsweise der Quick Sort.

Wir können viel über Algorithmen lernen, indem wir die verschiedenen Verfahren zum Sortieren studieren. Letztendlich erreichen sie alle dasselbe Ziel. Doch der Weg ist sehr unterschiedlich.

Programmieren lernen

Wer programmiert, entwirft zuerst einen Algorithmus. Erst danach wird der Algorithmus in einer Programmiersprache codiert und getestet.

Der Lernprozess geht Hand-in-Hand: Wer Programmieren lernen will, braucht viele kleine Beispiele, um gleich auch zu lernen, wie ein Algorithmus entsteht. Der Bubble-Sort ist ein klassischer Algorithmus, der zu jeder Ausbildung dazu gehört, und schon einige Grundkenntnisse voraussetzt.

Damit du diese Grundkenntnisse erlangen kannst, haben wir das E-Book Spiel mit Python geschrieben. Schau rein:

Algorithmen Entwickeln E-Book

Hol dir das kostenlose E-Booklet über die Grundlagen der Entwicklung von Algorithmen

Veröffentlicht am

Variablen tauschen in Python und Java

Variablen Werte tauschen

Variablen tauschen in Python und Java

Die Werte zweier Variablen sollen vertauscht werden. Eine alltägliche Anforderung die es in sich hat. Ein Rezept funktioniert in jeder Programmiersprache. Doch Python bietet eine besonders einfache Möglichkeit.

Autorin: Ursula Deriu

Werte von Variablen vertauschen mit Java

Dies ist ein häufig gesehener Anfängerfehler:

/* Variablen definieren und initialisieren */
int a = 47;
int b = 11;
/* Variablen tauschen */
a = b;
b = a;
/* Variablen ausgeben */
System.out.println("a="+a+" b="+b);

Das Ergebnis der Bemühung sieht so aus:

a=11 b=11

Die Erklärung ist mehrstufig:

Das Gleichheitszeichen

Das Gleichheitszeichen ist nicht die mathematsiche Gleichheit sondern der Zuweisungsoperator: Der Wert der Variablen links vom Zuweisungsoperator wird mit dem Wert der Variablen rechts vom Zuweisungsoperator überschrieben. Der alte Wert geht dabei verloren.


  • Der Befehl a  = b bewirkt, dass der Wert von b, also 11 in die Variable a kopiert wird. Die Variable a hat danach den Wert 11.
  • Der nachfolgende Befehl b = a bewirkt, dass der Wert von a, der jetzt ja 11 beträgt, in die Variable b kopiert wird.

So entsteht das Ergebnis.

Die Abhilfe ist einfach – eine Hilfsvariable:

int hilfsvariable = a;
a = b;
b = hilfsvariable;

Was passiert:

  • Mit int c = a wird eine neue Variable mit der Bezeichnung c definiert und mit dem Wert der Variablen a initialisiert. hilfsvariable hat also den Wert 47;
  • a = b kopiert den Wert der Variablen b in die Variable a. a hat also den Wert 11.
  • b = c kopiert jetzt den Wert der Variable hilfsvariable in die Variable a und diese nimmt damit wie erwartet den Wert 47 an.

Fertig. Das Rezept funktioniet in jeder Programmiersprache – auch in Python.

Variablen tauschen in Python – einfache Variante

Python ist keine typsichere Sprache, wir brauchen also den Datentyp einer Variablen nicht zu definieren. Der Python-Interpreter findet diesen für uns heraus. Der Java Code aus unserem Beispiel sieht in Python so aus:

a = 47
b = 11
c = a
a = b
b = c
print(f'a={a} b={b}')

Probier gleich aus auf dem Python Playground.

Variablen tauschen in Python – fortgeschrittene Variante

Python bietet viel Magie – auch für das Tauschen von Variablenwerten. Statt drei Zeilen reicht eine Zeile: (b, a) = (a, b). Sehr intuitiv, nicht wahr.

a = 47
b = 11
(b, a) = (a, b)
print(f'a={a} b={b}')

Probier gleich aus auf dem Python Playground.

Doch was steckt dahinter? Viele Konzepte laufen zusammen, um diese einfach Möglichkeit anzubieten.


Eine Variable in Python bedeutet eigentlich nur einen Verweis auf eine Stelle im Memory. Also eine Adresse. Der Python-Interpreter den Variablen während der Programmausführung die jeweiligen Adressen zu. Das ist auch in anderen Programmiersprachen so.  Der Artikel Primitive Datentypen vergleicht Java und Python im Hinblick auf die Art und Weise, wie Variablen gespeichert werden.

Der Fachbegriff für Verweis ist Pointer (oder Zeiger). Und ein Pointer ist eigentlich eine Adresse im RAM. Die Speicherstellen im RAM sind ja durchnummeriert und die Nummer dient als Adresse. Das können wir uns vorstellen, wie auf diesem Bild:

Variablen und Pointer
Die Speicherstellen sind im RAM nummeriert, d.h. adressiert. So werden Verweise auf Speicherstellen gebildet.

a bedeutet also eigentlich eine Adresse, also ein Zeiger ins RAM (Random Access Memory). Ohne sich darum zu kümmern, verwenden Python-Programmierer ständig Pointers.

In anderen Sprachen, beispielsweise C, sorgt man sich beim Programmieren ständig um Pointers.


In Python ist (a, b) ein Tupel – also ein eigener Datentyp. Eigentlich müsste man sagen, ein Objekt des Typs Tupel. Doch das ist zu umständlich.

Tupel sind eingebaute Datentypen – und so können wir sie auch ohne speziellen Aufruf eines Konstruktors verwenden – also einfach (a, b) schreiben und damit ist das Tupel gebildet. Und auch ein Tupel ist als Objekt eigentlich nur ein Pointer.

Tupel im Memory
Tupel haben eine eigene Adresse im Memory. Sie enthalten wiederum Adressen, die auf die Tupel-Elemente verweisen.


Das Gleichheitszeichen ist in Python – und nicht nur dort – der Zuweisungsoperator:
Der Wert des Ausdrucks rechts vom Zuweisungszeichen, wird der Variablen links vom Zusweisungszeichen zugeordnet.

Eigentlich werden nur Pointers umgehängt – Das Bild zeigt die folgenden Befehle:

a = 47
c = a
Zuweisung im Memory
Eine Zuweisung hängt Pointer um.

Und das auf die Spitze getrieben münde bei Python in den Code (b, a) = (a, b).

Was der Code bewirkt, sehen wir im Python Playground:

Python Code zum Vertauschen von Variablen

Die Werte der Variablen a und b werden also vertauscht.

So elegant geht das und so viel steckt dahinter.

Der Aufwand der Python-Magie

Eine Extra-Variable c einfügen erscheint auf den ersten Blick umständlich und Python erscheint viel sparsamer.

Doch der Schein trügt: In Python haben wir sogar zwei Extra-Objekte: nämlich das Tupel (a, b) und das Tupel (b, a).

So gesehen ist Python für die Anwender sparsam, doch die Python-Magie kostet im Hintergrund ganz schön viel Platz und auch viel Ausführungszeit.

Zeit ist Geld – das ist nichts Neues. Als Programmiererinnen und Programmierer konzentrieren wir uns gerne auf die unmittelbaren Fragestellungen und da ist Python natürlich attraktiv.

Python-Magie und Datentypen

Python ist eine enorm flexible Sprache. Tupel sind nur einer der Python Datentypen. Hol dir unser praktisches Cheat Sheet mit allen eingebauten Python Datentypen.:

Veröffentlicht am Schreib einen Kommentar

Hardwarekenntnisse für Programmierer

Hardwarekenntnisse für Programmierer

Hardwarekenntnisse für Programmierer

Die Von-Neumann-Architektur ist ein Modell, welches das für die Programmierung notwendige Basisverständis über die Funktion eines Computers vermittelt.

Autorin: Ursula Deriu

Software und Hardware

Elektroingenieure befassen sich mit der Hardware von Computern, also mit den elektronischen Bauteilen und deren Funktionsweise.

Programmierer schreiben Software für Computer. Damit sind Programme gemeint, welche den Computer eine bestimmte Funktionalität ausführen lassen. Ein Programmierer braucht ein gewisses Grundverständnis für die Hardware. Dieses verschafft er sich mit einem Modell.

Modelle sind für den Programmierer Hilfsmittel, um die Hardware so zu verstehen, dass er Programme korrekt schreiben kann.


Die Von-Neumann-Architektur ist  eines der frühesten Modelle und es ist immer gut geeignet, um als Anfänger der Programmierung den Einstieg in die Thematik zu finden. Wir betrachten die einfachste Darstellung der Von-Neumann-Architektur. Sie umfasst die folgenden Elemente:

Prozessor (CPU)

Der Prozessor (auch CPU, Central Processing Unit – Zentraleinheit) – ist die wichtigste Komponente eines Computers. Hier wird die eigentliche Rechenarbeit erledigt. Verarbeitet werden Folgen von Bits. Diese werden in Registern gehalten, das sind spezielle Bereiche, in welchen Rechenoperationen ausgeführt werden können.

Aus Sicht der Elektronik handelt es sich bei Bits um Schalterzustände. Aus Sicht der Programmierer können Bits die Werte 0 und 1 annehmen. Die CPU verarbeitet also eine Folge von 0- und 1-Werten. Dabei werden die Regeln der Bool‘schen Logik und der Arithmetik berücksichtigt.

Memory (RAM)

Das Memory (genauer RAM = Random Access Memory)– hier werden Zwischenergebnisse festgehalten, oder auch ganze Programme geladen, um sie schneller verarbeiten zu können. Wird der Rechner ausgeschaltet, dann geht der Inhalt des Memorys verloren. Erst beim Wiederhochfahren des Computers, erhält das Memory wieder Inhalte.

Schematische Darstellung der Von-Neumann-Architektur

Input- und Output-Devices (I-O Devices)

Ein Computer ist nicht Selbstzweck sondern er verarbeitet Daten, welche er durch ein Eingabegerät erhält und gibt sie weiter an ein Ausgabegerät. Input- und Output-Geräte, also Ein- und Ausgabegeräte, sind sehr vielfältig, vom Touchscreen, über die Tastatur, eine Festplatte oder anderen Computern, ist nahezu alles denkbar.


Eine Festplatte, neu auch ein SSD (Solid State Drive) ist ein spezieller Datenspeicher erhält Daten dauerhaft, d.h. sie bleiben erhalten, auch wenn der Computer ausgeschaltet wird.


Ein Bus (Control-Bus, Address-Bus, Data-Bus) dient dazu, Kontroll-Information, Adressen und Daten zwischen der CPU dem Memory und den Input- und Output-Geräten zu transportieren.

Die von Neumann Architektur ist eine Referenzarchitektur. Seit ihrere Entwicklung wurde sie weiter verbessert und es kamen weitere Architekturen dazu.

Das Verständnis der von Neumann Architektur ist hilfreich, um Programmieren zu lernen.

Raspberry Pi als Beispiel einer realisierten Von-Neumann Architektur

Raspberry Pi ist der beliebte Einplatinen-Rechner – Single-Board Computer (SBC). Auch dieser implementiert im Wesentlichen die von Neumann Architektur. Wer einen SBC erwirbt, erhält diesen meist eine Platine ohne Gehäuse geliefert. Die Platine enthält die gedruckte Schaltung. CPU, RAM und I-O Devices werden auf der Platine montiert, die Busse werden als Schaltung gedruckt.

Komponenten Raspberry Pi 4
Die wichtigsten Elemente der Von-Neumann-Architektur werden auf der Platine montiert. Die Busse werden "gedruckt" und sind als feine Linien auf der grünen Platine erkennbar.

Das Raspberry Pi verfügt über mannigfaltige Input- und Output-Devices: USB, Ethernet, HDMI. Es gibt kaum eine Device, die man nicht anschließen kann – Tastatur, Maus, Monitor, Kamera und vieles mehr.

Auch die Netzwerk-Verbindungen sind möglich, via Festnetz (Ethernet) oder auch via WiFi.

Die Busse sind aufgedruckt, wer genau hinsieht, erkennt die feinen Linien auf der grünen Platine.

Aus Sicht der Programmierer ist jeder  Computer ist so aufgebaut – ob ganz klein, beispielsweise als Smart-Watch oder ganz groß, wie bei einem Server in einem Rechenzentrum. Und das schon seit den ersten Computern und daran hat sich nicht viel geändert. Elektro-Ingenieuresehen das anders: sie verbessern die einzelen Hardware-Komponenten und entwickeln neue I-O-Devices.

Welche Klammer bedeutet was? [] oder{} oder () oder gar (()) ?

Cheat Sheet für Python-Anfänger: Wichtigste Python-Datentypen

Die wichtigsten Built-in-Datentypen von Python auf einen Blick. Ein unverzichtbarer Spickzettel beim Durchstarten mit Python. Einfach herunterladen.

Mit Python Programmieren lernen