The power of head up displays

 Head up displays are common special effects in scifi movies. Since the 1980s lots of films have demonstrated these visual effects. Most of the audience thinks, that the head up display isn't artificial intelligence but its only the artist representation of possible future robotics.

Its a bit surprising to explain that a head up display is the fundamental building block for artifcial intelligence because they are showing grounded language. The typical head up display is formatted in a key/value syntax, similar to a json file. Example for a warehouse robot:

location: cell B, north
movement: east
speed: 4 km/h
gripper: empty
obstacle: no
target: cell A
battery: 81%

All the important information can be shown in this syntax. The key/value format converts the camera picture into a text adventure game. A parser can analyze the textual information and decide what the robot should do next. For example, if the battery is below 20% the robot needs to find the charging station, And if there is an obstacle ahead, the robot needs to stop.

So we can say, that advanced robots aren't controlled by a AI algorithm but by the head up display. The information are the input for the decision making system, the head up display consists of the state space of a robot. If the robot decides for the wrong action, sometihng is wrong with information in the head up display.

Trash collecting robot with head up display

 

The upcoming Claude mythos LLM

 There are rumors available about a new large language model called "Claude mythos" which wasn't released yet. Its not very hard to describe its potential features because existing large language models have a lots of disadvantages.

Chatgpt and co are able to generate source code for example in Python and C but they are not able to execute in a virtual environment. The human user will notice this restriction because the LLM generated code contains sometimes smaller errors. For example the python interpreter might report that in a line 30 something is wrong. The current situation in may 2026 is, that the user has to submit the error message from python to the chatgpt LLM and then the chatbot will create the improved version which might contain another error. It takes a lot of time to produce a runnable software with such a feedback loop.

Suppose a large language model has an internal python interpret which can execute sourcecode and improve it. This would lower the needed feedback loops with a human and allows the LLM to generate error free programs in the frist attempt.

In general its about an environment to test software or test the actions of a robot. The assumption is that Claude mythos will have such a built in environment which improves AI based software engineering drastically.

The proposed abilities of Claude mythos to find bugs in existing software project is perhaps working with the same method. Before its possible to find a bug and fix it, there is a need to simulate the software in a simulator. Such a simulator is used by human programmers since years, its mostly a Gnu compiler which converts c code into binary code plus a virtual machine which is qemu to run the software. Every possible bugfix is compiled first to verify that there is no error in the code and then the binary file is run in a simulator to verify if the software is fixing the problem. The chance is high is that claude mython works with a similar principle.

This would allow a computer not only to generate source code, but also determine the outcome of the generated code. Such an LLM would be more useful than existing LLM which do not have such features. 

Das Symbol grounding problem an einem praktischen Beispiel

Grounded language ist ein interdisziplinäres Problem was ein umfangreiches Fachwissen in sehr unterschiedlichen Disziplinen wie Informatik, Linguistik und Robotersteuerung erfordert. Es ist daher nötig, die Thematik zu vereinfachen anhand eines praktischen Beispiels. Ein Anfang ist eine Landkarte auf der ein Mauscursor bewegt wird. Der nutzer kann die mauf einen belieben Punkt bewegen z.B. auf einen roten Kreis oder ein gelbes Quadrat. Das Computerprogram zeigt für die Mauspostition die [tags] an, z.B. "[kreis] [grün]", oder "[rechteck] [klein]".

zumindest für das MInibeispiel mit der Landkarte auf dem geoemtrische Objekte zu sehen sind, ist damit das symbol grounding problem gelöst.

Ähnlich wie bei einer perspektivischen Darstellung in der Malerei gilt es also die REalität auf ein koordinatensystem abzubilden. Bei grounding problem bestehen die koordinaten aus einer [tag] liste. Der User zeigt auf einen punkt z.B. (100,30) und der Computer bestimmt die Tags für das Objekt an diesem Punkt.

Obwohl die technische Umsetzung leicht ist, kann über grounded language ein erstaunlich leistungsfähiges KI System erstellt werden. Ab dem moment wo der Computer tags ausgeben und parsen kann ist darüber eine Kommunikation möglich. Ein Beispiel:

Angenommen die beschriebene semantische Kamera wurde für ein Jump'bn'Run Videospiel implementiert, das heißt die Software vermag anhand der Tilemap sagen, ob der Mousecursor auf einem Abgrund, einem coin, einem powerup, einem Gegner oder auf einer Plattform steht. Dann kann diese Information in einer Regel referenziert werden, wie "gehe bis zum Abgrund und halte an, dann springe darüber und laufe bis zum Coin". Diese komplexe Befehlsfege referenziert auf erkannte Tags in dem Computerspiel, der parser kann dies auswerten und versteht was der Benutzer möchte. Nicth weil ein hochkomplexer Algorithmus im Hintergrund arbeitet, sondern weil ein mensch maschine interface existiert auf das man verweisen kann.

 

Der sourcecode und der screenshot zeigen nicht das geometrie problem sondern ein robot in a maze spiel bei dem ein roboter items sammeln muss. Es gibt in der Statuszeile eine semantische Event Erkennung. Der Roboter bewegt sich in der Karte und parallel dazu wird in der Textbox die aktuelle Situaton beschrieben, ein wenig so wie einem frühen Textadventure. Über besagte Statuszeile wird der game state des robtoers definiert und zwar im linguistischen Raum und nicht im geometrisch mathematischen Raum.

import pygame
import sys
import random

# Initialize Pygame
pygame.init()
pygame.font.init()

# --- Configuration Constants ---
GRID_SIZE = 40  # Pixels per cell
GRID_COLS = 20
GRID_ROWS = 12

# Textbox dimensions (40 chars wide, 4 lines high roughly translates to this)
TEXTBOX_HEIGHT = 100
SCREEN_WIDTH = GRID_COLS * GRID_SIZE
SCREEN_HEIGHT = (GRID_ROWS * GRID_SIZE) + TEXTBOX_HEIGHT

# Colors (RGB)
COLOR_STREET = (240, 240, 240)
COLOR_HOUSE = (70, 130, 180)
COLOR_ROBOT = (220, 50, 50)
COLOR_TRASH = (40, 180, 99)
COLOR_TEXTBOX_BG = (30, 30, 30)
COLOR_TEXT = (255, 255, 255)
COLOR_GRID = (210, 210, 210)

# --- Event Log System ---
# The 12 grounded language events:
# 1. "System initialized. Roomba ready."
# 2. "Moved North."
# 3. "Moved South."
# 4. "Moved East."
# 5. "Moved West."
# 6. "Obstacle detected at North."
# 7. "Obstacle detected at South."
# 8. "Obstacle detected at East."
# 9. "Obstacle detected at West."
# 10. "Grid boundary reached."
# 11. "Trash item successfully collected!"
# 12. "Area clear. No trash nearby."

event_logs = ["System initialized. Roomba ready.", "", "", ""]

def log_event(message):
    """Adds a new event to the log, keeping only the last 4 events."""
    global event_logs
    if event_logs[-1] != message: # Avoid spamming identical consecutive logs
        event_logs.append(message)
        if len(event_logs) > 4:
            event_logs.pop(0)

# --- Map & Environment Setup ---
# 0 = Street (Pathway), 1 = House (Obstacle)
maze = [[0 for _ in range(GRID_COLS)] for _ in range(GRID_ROWS)]

# Generate mock "blocks" of houses to look like a street map
random.seed(42) # Seed for consistent map generation
for r in range(1, GRID_ROWS - 1, 3):
    for c in range(1, GRID_COLS - 1, 4):
        # Create a 2x2 or 2x3 house block
        block_w = random.randint(2, 3)
        block_h = 2
        for bh in range(block_h):
            for bw in range(block_w):
                if r + bh < GRID_ROWS - 1 and c + bw < GRID_COLS - 1:
                    maze[r + bh][c + bw] = 1

# Spawn Trash Items
trash_positions = set()
while len(trash_positions) < 10:
    tr = random.randint(0, GRID_ROWS - 1)
    tc = random.randint(0, GRID_COLS - 1)
    if maze[tr][tc] == 0:  # Must be on a street
        trash_positions.add((tc, tr))

# Spawn Robot
robot_x, robot_y = 0, 0
while maze[robot_y][robot_x] != 0:
    robot_x = random.randint(0, GRID_COLS - 1)
    robot_y = random.randint(0, GRID_ROWS - 1)

# --- Simulation Setup ---
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Robot Street Simulator")
clock = pygame.time.Clock()
font = pygame.font.SysFont("Courier", 18) # Monospace font for predictable char width

def check_surroundings(rx, ry):
    """Scans adjacent cells to log nearby obstacles."""
    # North
    if ry - 1 < 0: pass 
    elif maze[ry - 1][rx] == 1: log_event("Obstacle detected at North.")
    # South
    if ry + 1 >= GRID_ROWS: pass
    elif maze[ry + 1][rx] == 1: log_event("Obstacle detected at South.")
    # West
    if rx - 1 < 0: pass
    elif maze[ry][rx - 1] == 1: log_event("Obstacle detected at West.")
    # East
    if rx + 1 >= GRID_COLS: pass
    elif maze[ry][rx + 1] == 1: log_event("Obstacle detected at East.")

# Initial scan
check_surroundings(robot_x, robot_y)

# --- Main Loop ---
# --- Main Loop ---
running = True
while running:
    for event in pygame.event.get():
        # FIX: Changed event.get_type() to event.type
        if event.type == pygame.QUIT:
            running = False
            
        # FIX: Changed event.get_type() to event.type
        elif event.type == pygame.KEYDOWN:
            dx, dy = 0, 0
            move_dir = ""
            
            if event.key == pygame.K_UP:
                dy = -1
                move_dir = "North"
            elif event.key == pygame.K_DOWN:
                dy = 1
                move_dir = "South"
            elif event.key == pygame.K_LEFT:
                dx = -1
                move_dir = "West"
            elif event.key == pygame.K_RIGHT:
                dx = 1
                move_dir = "East"
                
            if dx != 0 or dy != 0:
                new_x = robot_x + dx
                new_y = robot_y + dy
                
                # Check Grid Boundary
                if not (0 <= new_x < GRID_COLS and 0 <= new_y < GRID_ROWS):
                    log_event("Grid boundary reached.")
                # Check House Obstacle Collision
                elif maze[new_y][new_x] == 1:
                    log_event(f"Obstacle detected at {move_dir}.")
                # Move Valid
                else:
                    robot_x = new_x
                    robot_y = new_y
                    log_event(f"Moved {move_dir}.")
                    
                    # Check Trash Collection
                    if (robot_x, robot_y) in trash_positions:
                        trash_positions.remove((robot_x, robot_y))
                        log_event("Trash item successfully collected!")
                    
                    # Scan environment post-movement
                    check_surroundings(robot_x, robot_y)
                    
                    # Check if all clear
                    if not trash_positions:
                        log_event("Area clear. No trash nearby.")

    # --- Drawing Environment ---
    screen.fill(COLOR_STREET)
    
    # Draw Grid and Houses
    for r in range(GRID_ROWS):
        for c in range(GRID_COLS):
            rect = pygame.Rect(c * GRID_SIZE, r * GRID_SIZE, GRID_SIZE, GRID_SIZE)
            if maze[r][c] == 1:
                pygame.draw.rect(screen, COLOR_HOUSE, rect)
            pygame.draw.rect(screen, COLOR_GRID, rect, 1)

    # Draw Trash Items
    for (tx, ty) in trash_positions:
        trash_rect = pygame.Rect(tx * GRID_SIZE + 10, ty * GRID_SIZE + 10, GRID_SIZE - 20, GRID_SIZE - 20)
        pygame.draw.rect(screen, COLOR_TRASH, trash_rect, border_radius=3)

    # Draw Robot
    robot_rect = pygame.Rect(robot_x * GRID_SIZE + 6, robot_y * GRID_SIZE + 6, GRID_SIZE - 12, GRID_SIZE - 12)
    pygame.draw.ellipse(screen, COLOR_ROBOT, robot_rect)

    # --- Drawing Grounded Language Textbox ---
    # Draw Textbox background container
    textbox_rect = pygame.Rect(0, GRID_ROWS * GRID_SIZE, SCREEN_WIDTH, TEXTBOX_HEIGHT)
    pygame.draw.rect(screen, COLOR_TEXTBOX_BG, textbox_rect)
    pygame.draw.rect(screen, COLOR_TEXT, textbox_rect, 2) # Border
    
    # Render the 4 lines of text
    for idx, log in enumerate(event_logs):
        # Clip string to 40 characters maximum to respect specification constraints
        truncated_log = log[:40] 
        text_surface = font.render(truncated_log, True, COLOR_TEXT)
        screen.blit(text_surface, (15, (GRID_ROWS * GRID_SIZE) + 10 + (idx * 20)))

    pygame.display.flip()
    clock.tick(30)

pygame.quit()
sys.exit()

Wie Computer das denken lernen

 In der Geschichte der Künstlichen Intelligenz gab es zahlreiche versuche einer Maschine das Denken beizubringen. Zunächst wurde Denken über Algorithmen simuliert. Die Vorstellung war, dass eine denkende Maschine ein Programm abarbeitet und das Ergebnis dann eine Entscheidung ist z.B. den Roboter nach norden zu steuern.

Theoretisch mag das Konzept sinnvoll klingen es scheitert jedoch sobald man versucht einen solchen Algorithmus zu programmieren. Es ist nicht klar, wie man genau anfängt und wie vorhandene Algorithmen verbessert werden können. In der Summe ist der Versuch Denken als Algorithmenausführung zu definieren gescheitert.

Eine neuere und erfolgversprechende Methode dennoch dem Computer das Denken zu lehren ist die natürliche Sprache. Die Annahme lautet dass Denken identisch ist mit Sprachverarbeitung. Um Sprache von einem Computer verbeiten zu können ist ein interaktiver Ansatz möglich. Man sendet an den Roboter z.B. einen Satz wie "fahre nach norden" und der Computer übersetzt den Satz in eine Handlung. Oder man sendet an den Computer ein Wort wie "Apfel" und der Computer zeigt daraufhin das passende Bild mit dem Obst.

Wenn man die interaktion mit dem Computer in datensätzen dauerhaft speichert und darüber neuronale Netze trainiert erhält man moderne LLM Chatbots wie sie seit 2023 entwickelt werden. Diese kommen menschlichen Denken sehr nahe.

Das besondere an der sprachbasierten Künstlichen Intelligenz ist, dass sie nicht länger von Algorithmen definiert ist. ZWar beinhalten Large language modelle auch eine Softwarekomponente doch der weitaus wichtigere Teil ist die .csv Datei worin Frage / Antwort Paare gespeichert sind.

Productivity boost with artificial Intelligence

 Programming in computer science works different in each year. In the 1980s a typical pong clone was realized in Assembly language which takes around 2 weeks until the program is running error free. The result is, that there are two paddles on the screen which can be moved with a joystick and the self created game engine counts the score.

In the 1990s the typical programming language was C which allows to program the same game much faster. Its assumed that the average programmer can create a pong clone in C in around 3 days by using existing graphics libraries and tutorials from the Internet. This might explain why C has replaced assembly programming.

Todays situation in the year 2026 is, that with the help of large language models its possible to create python code for a pong videogame in around 10 minutes. The programmer formulates the text prompt and is testing the generated python code on the local macihne.

In future its likely that the producivity will increase more, perhaps its possobiel to create a pong clone in under 3 seconds and program more advanced software also with Artificial intelligence.

Chinesische Spionin erkundet Roboter-Sortieranlage

 Ort: Ein verlassener Kopierraum im Untergeschoss des Instituts für Robotik und Systemtheorie, Technische Universität.

Zeit: Später Abend, im Jahr 2026.

Das sanfte grüne Licht der Notbeleuchtung warf lange Schatten auf die Flure. Mei Lin – von ihren Kollegen nur „die fleißige Postdoktorandin“ genannt – bewegte sich lautlos. Sie war eine sogenannte Sea Turtle: In China geboren, im Ausland hochgradig ausgebildet um ihrer Heimat zu dienen – wenn auch auf eine Weise, die nicht in ihrem Arbeitsvertrag stand.

Sie betrat das Labor für Autonome Systeme. In der Mitte des Raums stand „ROB-SORT 4“, ein Prototyp, der die europäische Kreislaufwirtschaft revolutionieren sollte. Es war kein glänzender humanoider Roboter, sondern ein funktionaler Industriearm über einem Förderband. Doch das Herzstück war die semantische Schnittstelle.

An der Seite des Steuerungsgehäuses leuchtete ein nostalgisch anmutendes, aber hochpräzises 40x4 Zeichen LCD-Display.

Mei Lin: (flüstert leise auf Mandarin, während sie ihr Smartphone zückt) „Endlich. Das Grounded Language Model in Echtzeit.“

Sie aktivierte das Förderband im Testmodus. Ein zerknitterter Joghurtbecher fuhr unter die Kamera. Der Roboterarm hielt inne. Auf dem Display erschienen in rascher Folge die Zeilen, die das neuronale Netz gerade ‚dachte‘:

    OBJEKT 0815: BECHER. FARBE: WEISS/BLAU.
    MATERIAL: PP-KUNSTSTOFF. GEWICHT: 12G.
    VOLUMEN: KLEIN. STATUS: LEICHT DEFORMIERT.
    AKTION: GREIFER-MODUS 2 (SOFT-GRIP). ZIEL: BOX 4.

Mei Lin hielt den Atem an. Das war die Lösung. Während die deutschen Ingenieure noch darüber stritten, ob die semantische Beschreibung der Objekte die Latenzzeit zu stark erhöhte, hatte die KI hier bereits die perfekte Brücke zwischen Sprache und physischer Aktion geschlagen. Die „geerdete Sprache“ (Grounded Language) erlaubte es dem Roboter, physikalische Eigenschaften wie „Gewicht“ und „Material“ nicht nur als abstrakte Zahlen, sondern als logische Beschreibungen zu verarbeiten, bevor der Greifbefehl berechnet wurde.

Sie machte mehrere hochauflösende Fotos von dem Display, während verschiedene Müllobjekte – eine Glasflasche, eine rostige Konservendose, ein Stück Wellpappe – analysiert wurden.

Mei Lin: „Farbe, Größe, Material, Gewicht... alles übersetzt in natürliche Sprache. Genial einfach. Einfach genial.“

Sie wusste, dass die Cloud-Server des Instituts streng überwacht wurden. Ein Upload großer Datenmengen nach Peking würde sofort die Alarmglocken des Verfassungsschutzes schrillen lassen. Doch Mei Lin hatte einen archaischen Plan.

Sie schlich zurück in den Kopierraum im Keller. Dort stand ein altes Kombigerät aus den frühen 2000ern, das nur noch für die Kommunikation mit der konservativen Universitätsverwaltung genutzt wurde. Ein analoges Faxgerät.

Sie schloss ihr modifiziertes Smartphone an den Telefonanschluss an. Die digitalen Fotos der 40x4-Displays wurden in ein analoges Signal umgewandelt.

Piiiep-krrr-tsch-hiiiiiii.

Das Geräusch war Musik in ihren Ohren. In diesem Moment wurden die exakten Parameter der deutschen Spracherkennung und die daraus resultierenden Greifer-Entscheidungen über eine gesicherte Telefonleitung nach Peking übertragen.

Szenenwechsel: Ein Hochsicherheitslabor im Bezirk Haidian, Peking. Drei Stunden später.

Chefingenieur Zhang: (starrt auf die einlaufenden Faxe, die ein Assistent eilig sortiert) „Was ist das? Analoges Fax? Wie kreativ von ihr.“

Assistent: „Es sind die Datensätze vom ROB-SORT Projekt, Herr Direktor. Sehen Sie sich die Beschreibungen an. Das System nutzt natürliche Sprache als Filter für die Greifer-Sensorik. Wir haben versucht, das rein mathematisch über Drehmomente zu lösen, aber die Fehlerquote war zu hoch. Wenn wir die KI erst beschreiben lassen, was sie sieht – ‚schweres Glas, glatte Oberfläche‘ – kann die Feinmotorik des Greifers sofort darauf reagieren.“

Chefingenieur Zhang: (schlägt mit der flachen Hand auf den Tisch) „Wir haben bereits die Hardware-Basis in der Sortieranlage Süd-Peking stehen. Wir brauchen keine drei Jahre für die Validierung wie die Deutschen. Wir nehmen diese Sprachlogik, füttern sie in unser Modell und stellen die Produktion sofort um. Wir überspringen die gesamte Testphase für die mechanische Integration.“

Drei Monate später: Berlin.

Professor Baumgartner (ein entfernter Kollege des Robotik-Lehrstuhls) saß in seinem Büro und starrte auf seinen Monitor. Er öffnete einen Link zu einer Pressemitteilung der Tsinghua University und der Beijing Waste Management Group.

Professor Baumgartner: (ruft entsetzt seinen Oberassistenten herein) „Haben Sie das gesehen? Die Chinesen haben gestern die größte automatisierte Müllsortieranlage der Welt in Betrieb genommen. Sie nutzen ein System namens ‚Natural Language Grasping‘.“

Oberassistent: „Aber Professor, das ist doch exakt unser Ansatz! Wir wollten nächste Woche erst den Förderantrag für die Pilotanlage stellen. Wir sind noch mitten in der Kalibrierung des 40x4-Displays für die Fehlerprotokolle.“

Professor Baumgartner: (lässt die Schultern sinken) „Schauen Sie sich die Bilder an. Die Greifer sind identisch mit unseren Entwürfen. Sogar die Beschreibungsparameter – Farbe, Größe, Material, Gewicht – sind in derselben Reihenfolge gelistet. Wie ist das möglich? Wir haben das Projekt noch nicht einmal publiziert!“

Er blickte aus dem Fenster auf den Campus. Mei Lin ging gerade unten über den Hof, ein Tablet im Arm, freundlich lächelnd.

Professor Baumgartner: „Vielleicht sind wir Deutschen einfach zu langsam geworden. Während wir noch die Normen für das Display festlegen, haben die anderen den Müll der Welt schon sortiert.“

Mei Lin strich sich eine Strähne aus dem Gesicht. In ihrer Tasche vibrierte ihr Telefon. Eine Nachricht aus der Heimat: „Die Anlage läuft stabil. 99,8 % Trennungsquote. Gute Arbeit, Sea Turtle.“ Sie löschte die Nachricht und betrat das Institut für eine weitere Schicht „fleißiger“ Forschung.

Ferngesteuerte Robotik im Jahr 1999

 Ort: Ein stickiges Büro an der Technischen Universität, vollgestellt mit Röhrenmonitoren und Stapeln von Fachzeitschriften.
Zeit: November 1999.

Professor Baumgartner: (starrt fassungslos über den Rand seiner Lesebrille) „Sagen Sie das bitte noch einmal, Herr Fischer. Ich möchte sichergehen, dass ich Sie in diesem akustisch suboptimalen Raum nicht missverstanden habe.“

Lukas: (nervös, ein zerknittertes Manuskript in der Hand) „Herr Professor, ich dachte an einen Paradigmenwechsel. Die Algorithmen für die autonome Navigation in komplexen Umgebungen sind... nun ja, sie stecken fest. Warum ersetzen wir die Logik nicht durch menschliche Intuition? Ein Roboter, der über eine Funkstrecke oder das neue Breitband-Internet ferngesteuert wird. Der Mensch übernimmt die Entscheidungsebene. Wir umgehen das gesamte Problem der Pfadplanung durch Telepräsenz.“

Professor Baumgartner: (lässt den Füllfederhalter fallen, das Geräusch hallt wie ein Schuss) „Telepräsenz? Sie wollen einen ferngesteuerten Spielzeugwagen bauen und das als Informatik-Dissertation verkaufen? Wir befinden uns an der Schwelle zum neuen Jahrtausend, Fischer! Die ganze Welt blickt auf die Automatisierung, und Sie wollen einen digitalen Marionettenspieler engagieren?“

Lukas: „Aber die Rechenleistung...“

Professor Baumgartner: (fällt ihm ins Wort) „Die Rechenleistung ist eine Ausrede für Denkfaulheit! Wissen Sie, was Sie da vorschlagen? Sie schlagen vor, die Informatik aus der Robotik zu entfernen. Wenn ein Mensch den Arm führt oder den Pfad wählt, findet keine Informationsverarbeitung im Sinne der Maschine statt. Das ist... das ist Zirkusarbeit. Ganz ehrlich, Fischer: Wenn das Ihr Verständnis von wissenschaftlichem Fortschritt ist, dann müssen wir uns ernsthaft fragen, ob dieses Institut der richtige Ort für Sie ist. Ich bezweifle unter diesen Umständen massiv, dass Sie die nötige Reife für eine Promotion besitzen.“

Lukas: (schluckt) „Ich wollte nur eine pragmatische Lösung für das Problem der lokalen Minima in der Navigation finden.“

Professor Baumgartner: „Pragmatismus ist das Ende der Grundlagenforschung! Wir lösen Probleme nicht, indem wir sie wegschieben. Wir lösen sie mathematisch. Setzen Sie sich.“

(Baumgartner wühlt in einem Stapel und zieht ein erst kürzlich erschienenes Paper hervor.)

Professor Baumgartner: „Haben Sie LaValle gelesen? Oder Kuffner? Nein? Natürlich nicht. Während Sie über Joysticks nachdenken, entwickeln kluge Köpfe den Rapidly-exploring Random Tree, kurz RRT. Das ist die Zukunft, Fischer! Es ist ein probabilistischer Algorithmus, der den Konfigurationsraum effizient durchsucht, indem er Bäume in Richtung unbesetzter Bereiche wachsen lässt.“

Lukas: „Ein zufallsbasierter Baum? Ist das nicht zu... stochastisch für präzise Manöver?“

Professor Baumgartner: „Es ist genial! Es löst das Problem der hohen Dimensionalität, an dem Sie mit Ihrem 'Tele-Hobby' kläglich scheitern würden. Sie werden folgendes tun: Sie vergessen diesen Unsinn mit der Fernsteuerung sofort. Sie werden ein Framework entwickeln, das RRT für nicht-holonome Systeme implementiert. Wir werden beweisen, dass die Maschine den Weg findet, ohne dass ein Mensch am anderen Ende der Leitung schwitzt.“

Lukas: „Verstehe, Herr Professor. Also ein rein algorithmischer Ansatz.“

Professor Baumgartner: „Ein wissenschaftlicher Ansatz. Gehen Sie in den Pool, lesen Sie die Veröffentlichungen von 1998 und '99 zum Thema RRT und zeigen Sie mir nächste Woche eine Simulation, die ohne menschlichen Eingriff funktioniert. Und Fischer... erwähnen Sie nie wieder das Wort 'fernbedient' in diesen Mauern. Wir bauen hier Intelligenz, keine Geisterfahrer.“

Lukas: „Ja, Herr Professor. Ich... ich mache mich sofort an die Arbeit.“

Professor Baumgartner: (murmelt, während Lukas das Büro verlässt) „Fernsteuerung... unfassbar. Als Nächstes schlägt er wohl noch vor, dass wir unsere Briefe per Fax verschicken, statt E-Mails zu schreiben.“