# Turtle-Lesson

Autor: Torsten Roeder
Lizenz: [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/)

FH Potsdam, 22.06.2021
FH Potsdam, 27.06.2022

http://pythonsandbox.com/turtle

- 15 Min Einführung
- 60 Min Übung
- 15 Min Reflektion

# Programmieren?

Mit »Programmieren« assoziieren wir häufig: Logisches Verstehen. Mathematik. Diese Dinge lehrten uns schon in der Schule das Fürchten. Aus diesem Grund hält man sich gerne weit davon entfernt und überlässt das Feld den sogenannten »Nerds« oder allgemein umgangssprachlich den Programmierern. Einem Klischee nach sind das hellhäutige Männer, die mit Kapuzenpullis in dunklen Zimmern sitzen und Bildschirme mit grün leuchtenden Zeichen schauen.

Wie bei vielen Stereotypen spiegelt das nur einen kleinen Teil der Realität wieder. Programmiererinnen und Programmierer verfügen mit ihren Kenntnissen über Spezialwissen. Die Allgemeinheit kann dem Programmieren nicht viel abgewinnen, und die meisten Geräte und Programmoberfläche verstecken den Programmcode dahinter so gut, dass man sich als Nutzer nicht darum kümmern muss. Programmiererinnen und Programmierer sind insofern auch ein kleines bisschen mitschuldig für die Situation.

Dies führt auch dazu, dass Kommunikation zwischen Insidern und Outsidern manchmal ein bisschen schief laufen. In den Geisteswissenschaften - dies ist der Bereich, den ich selbst studiert habe - läuft es oft so, dass Personen ohne Programmiererfahrung nur schlecht die Probleme und Schwierigkeiten einschätzen können, vor denen die Programmiererinnen und Programmierer stehen. Diese wiederum haben viel Arbeit, die Aufgaben technisch zu lösen. Und nicht immer ist die schnellste Lösung die nachhaltigste.

Beim Programmieren gibt es zudem inzwischen so viele unterschiedliche Ebenen, dass man nur noch im Team programmiert - denn eine einzelne Person kann selten alle Anforderungen abdecken. Allein bei einer einfachen Website kann bereits eine Vielzahl an Technologien zum Einsatz kommen: Eine häufige Kombi ist beispielsweise PHP, MySQL, HTML, JavaScript, CSS. Jede Programmiersprache deckt einen anderen Aspekt der Anwendung ab, beispielsweise die Datenhaltung, das Webdesign, der Datenaustausch zwischen Datenbank und Website, und so weiter.

Wie können wir diese Situation verändern? Es erscheint sinnvoll, sich dem Programmieren anzunähern, um das technologische Verständnis zu erhöhen und die Kommunikation zwischen Nerds und Nicht-Nerds zu verbessern. Dazu muss man nicht gleich eine komplette Programmiersprache erlernen, wofür man manchmal Jahre braucht (wie auch für eine natürliche Sprache). Ich möchte heute in dieser Gruppe das Experiment eines spielerischen Ansatzes wagen. Wir benötigen dazu lediglich einen Internet-Browser.

## Allgemeines

Bevor wir starten, vorweg ein paar allgemeine Aspekte des Programmierens. Wir kennen alle Kochbücher und Rezepte: Was sind Eigenschaften von Rezepten?

- Was bekomme ich am Schluss
- Was brauche ich dafür
- Wie komme ich dorthin
- Anleitung Schritt für Schritt (nimm dies, tu es dort hinein, füge jenes hinzu etc.)
- eventuell ein Kommentar (worauf ist zu achten, was kann man falsch machen)

Das Rezept ist eine Zielvorgabe mit Handlungsanweisungen für einen Menschen. Programmieren funktioniert ganz ähnlich, nur mit etwas anderen Rollen. Beim Programmieren gibt ein Mensch Handlungsanweisungen an eine Maschine. Der Unterschied: Während Menschen meistens nachfragen, wenn ihnen eine Anweisung seltsam vorkommt, ist dem Computer dies völlig egal. Computer besitzen nicht die Fähigkeit, etwas zu hinterfragen. Warum? Programmiersprachen sind so eingerichtet, dass es nur Befehle gibt, das heißt: Programmiersprachen kennen nur den Imperativ.

- Hinweis auf verschiedene "Levels" von Programmiersprachen

## Turtle

Für die Übung heute möchte ich mit [TURTLE](https://de.wikipedia.org/wiki/Turtle-Grafik) arbeiten. Die ursprüngliche Programmiersprache heißt [LOGO](https://de.wikipedia.org/wiki/Logo_(Programmiersprache)), wurde am MIT (Massachusetts Institute of Technology) in den 1960er Jahren entwickelt und dient speziell dem Gebrauch im Bildungssektor. In LOGO gibt man Anweisungen an eine Schildkröte (engl. Turtle), die sich den Kommandos über den Bildschirm bewegt und dabei eine Spur hinterlässt. Gibt man der Turtle die passenden Anweisungen, lassen sich komplexe Zeichnungen anfertigen.

Die Turtle kann einfache Befehle befolgen: Sie kann vor- oder zurücklaufen und sie kann sich drehen. Es gibt noch ein paar mehr Möglichkeiten, die wir gleich kennen lernen werden. Für das Experiment nutzen wir die "Turtle Sandbox": Diese basiert auf der Programmiersprache [Python](https://de.wikipedia.org/wiki/Python_(Programmiersprache)) und ist an das ursprüngliche LOGO angelehnt.

Python Sandbox: https://pythonsandbox.com/

Turtle Sandbox: https://pythonsandbox.com/turtle

Dokumentation: https://pythonsandbox.com/docs/turtle

Ich möchte folgende Ziele erreichen:
- Anweisungen codieren und ausführen
- Variablen einsetzen
- Anweisungen in einem Loop ausführen
- Anweisungen in eine Prozedur überführen
- rekursive Anweisungen ausführen (Bonuslevel)

Dies sind basale Techniken des Programmierens, die praktisch in jeder Programmiersprache vorkommen. Die Befehle sind hier und da etwas anders, aber im Grundsatz sind es immer wieder dieselben Befehle.

# Übungen

## Level 0: Setup

Turtle-Bibliothek importieren, Turtle-Variable festlegen

# dieser code kommt immer vorweg
import turtle # Turtle-Bibliothek laden
t = turtle.Turtle() # Turtle starten
t.speed(5) # Turtle-Geschwindigkeit festlegen

`#` = Kommentar / kein Befehl: alles Folgende in der Zeile wird ignoriert

## Level 1: Bewegen und drehen

`forward(x)` Turtle geht `x` Schritte vorwärts.
`backward(x)` Turtle geht `x` Schritte rückwärts.

`left(x)` Turtle dreht sich nach links um `x` Grad.
`right(x)` Turtle dreht sich nach rechts um `x` Grad.
`setheading(x)` Turtle schaut in Richtung `x` Grad.

`speed(x)` Stellt die Turtle-Geschwindigkeit auf `x`.
(1 = sehr langsam, 5 = mittel, 10 = sehr schnell, 0 = ohne Verzögerung)

`color("x")` Stellt die Turtle-Farbe auf `x`.
(z.B. "green", "red", "blue" u.s.w.)

## Level 2: Erstes Programm

Aufgabe: Dreieck / Quadrat / Fünfeck / Sechseck zeichnen (in Gruppen oder einzeln)

t.forward(10)
t.right(90)
# ...

## Level 3: Loops

# Anweisung ... `x` mal ausführen  
for i in range(x):
    # ...
    # auf Einrückung achten: genau 2 Leerzeichen

Aufgabe: Dreieck / Quadrat etc. mithilfe eines Loops zeichnen

## Level 4: Variablen

# Variable `a` auf den Wert `ABC` setzen
a = 50
# Turtle um `a` Schritte vorwärts bewegen
t.forward(a)

Verallgemeinern mit Variable (Zahl der Seiten, Länge der Seiten)

## Level 5: Prozeduren

def abc(x,y):
    [...]

Erzeugt eine Prozedur mit dem Namen `abc` und den Parametern `x` und `y`.
Bei Aufruf der Prozedur wird die Anweisung [...] ausgeführt.
Auf Einrückung achten: genau 2 Leerzeichen.

Aufgabe: Code in Prozedur überführen

## Level 6: Bedingungen

if bedingung:
    [...]

Führt die Anweisung [...] aus, wenn `bedingung` erfüllt ist.
Beispiel für `bedingung`: `5>3`,`1+1=3`
Auf Einrückung achten: genau 2 Leerzeichen.

if bedingung:
    [...]
else:
    [...]

Führt die Anweisung [...] nach der Zeile `if ...:` aus, wenn `bedingung` erfüllt ist, sonst aber die Anweisung nach der Zeile `else:`.

## Abschluss

Aufgabe: mehrere n-Ecke zeichnen (versetzt oder verschachtelt)

## Bonuslevel: Rekursionen

Aufgabe: Grafik rekursiv erstellen (z.B. Baum, Spirale ...)

### Schneeflocke

import turtle
t = turtle.Turtle()
t.speed(0) # 1:slowest, 3:slow, 5:normal, 10:fast, 0:fastest

def stern(a):
  for i in range(6):
    t.forward(a)
    if a>15:
      stern (a/3)
    t.backward(a)
    t.left(60)

stern(100)

### Baum

import turtle
t = turtle.Turtle()
t.speed(0)

def baum(stamm):
  if(stamm<10):
    return
  else:
    t.forward(stamm)
    t.left(30)
    baum(3*stamm/4)
    t.right(60)
    baum(3*stamm/4)
    t.left(30)
    t.backward(stamm)

laenge = int(input("Laenge des Baumstammes?"))

t.setheading(90)
t.back(laenge)

baum(laenge)

### Pyramide

import turtle
t = turtle.Turtle()
t.speed(0)

def pyramide(laenge):
  if laenge>10:
    for i in range(4):
      t.forward(laenge)
      t.left(90)
    t.left(45)
    t.up()
    t.forward(10)
    t.down()
    t.right(45)
    pyramide(laenge-10)

pyramide(100)

# Code-Hilfe

# Fazit

## Take Home Messages

Was haben wir über das Programmieren gelernt?

- nichts funktioniert, wie man es will
- man braucht Geduld
- Computer sind mega pingelig
- selten gelingt etwas
- es geht schief, was schiefgehen kann (Murphys Law)
- wenn etwas gelingt, sollte man es feiern (Umkehrung von Murphys Law)
- Dokumentation des Code hilft anderen und einem selbst

Wobei können diese Erkenntnisse helfen? (Diskussion)

## Wie geht es weiter?

Programming Historian, Python-Kurse:
http://programminghistorian.org/en/lessons/?topic=python