Des Doktors Bastelstube

[Der Doktor]

Also zu einem 4004 sag ich nicht nein

Ich bin froh bis jetzt zu Prozessoren gegriffen zu haben, die nur 5V Volt brauchen und nur einen CLK Input ohne Phi1,Phi2. Natürlich ist das nicht so kompliziert, aber ich habe gerade nicht so viele ICs hier rumfliegen, um das schnell zu realisieren. Und nur 3,3V oder 5V Supply. Wenn ich wieder da bin und mehr Zeit habe, werde ich mich damit aber auch beschäftigen

Habe mir auch mal wieder Gedanken zum U830C gemacht und eine gute Lösung gefunden, das Verhalten des Chips festzustellen. Ein Arduino Mega hat genug I/O Pins, um sie an alle Pins der CPU anzuschließen. Damit könnte ich alle Parts simulieren und genau sehen, wie der Prozessor funktioniert. Das werde ich im Dezember in Angriff nehmen.

[Der Doktor]

In etwa genau einem Monat bin ich aus Amerika zurück und werde wieder rumbasteln.

In der Zwischenzeit wurde ich von meinen Kurs aufgezwungen eine "WebApp" zu schreiben (was hat das eigentlich mit Systemprogramming zu tun, naja hinterfragen wir den Syllabus mal nicht). Da ich zu unkreativ für ein Spiel bin, und keine ToDo Liste oder Memeschrott implementieren will (FuckUp Utilities 9000?) habe ich mich dazu entschieden eine kleine VM zu schreiben für einen kleinen imaginären Prozessor. Wollte euch mal als Feedback rekrutieren

Zurzeit befindet sich Stack8 noch in der "Alpha" Phase. Aber am 4. Dezember ist Deadline und deswegen wird das recht schnell gehen. Die grundlegende VM und Assembler ist implementiert, dazu ein kleiner 4:3 Screen (Wortwörtlich 40 mal 30 Pixel) und ein Speicher und Stack Debugger. Das ganze heißt Stack8, weil der User nur 8KB Speicher bekommt, zudem benutzt die CPU die Stackarchitektur (Interner Stack statt Register) mit Tiefe 8 und besitzt nur 8 Instruktionen. Die Datenbreite ist 8-Bit, obviously. Meiner Meinung nach sollte das ganze auch Turingkomplett sein, heißt mit den Instruktionen kann man alles berechnen was man will.

Das Instructionset ist noch nicht ausgereift, will aber morgen den finalen Entwurf machen, nachdem ich ein bisschen rumgeforscht habe.
Zurzeit ist implementiert:

Code:

push -> pusht Inhalt einer absoluten Adresse auf den Stack
pop -> popt den obersten Eintrag auf den Stack in eine absolute Adresse
nand -> Nand auf den obersten beiden Einträgen
add -> Add ohne Carry auf den obersten beiden Einträgen
lfsh -> Left Shift auf den obersten Einträgen (1. Eintrag = Shiftamount, 2. Eintrag = to be shifted) -> Wird rausgeschmissen, da synthesierbar
jmple -> Jump if less or equal zur absoluten Adresse (Signed Comparison)
pushi -> pusht Inhalt des Pointers in der absoluten Adresse auf den Stack (TODO)
popi -> pusht den obersten Eintrag auf den Stack in die Adresse, auf die der Pointer zeigt, der an der absoluten Adresse liegt (TODO)
---
db -> pseudoinstruction, sagt dem Assembler, dass hier Daten liegen
[0-9a-zA-Z]+: -> Label
#[0-9]+ -> Absolute Adresse
----
Adresse 6991 - 8191: Screenmemory

Der Assembler ist caseinsentiv und parst das ganze sehr freizügig. Viele Leerzeichen oder überflüssige Argumente machen dem Assembler kein Problem. Bei Problemen wird aber zurzeit nur in die Webkonsole geloggt. Safari und Edge wollen noch nicht richtig, aber Firefox und Chrome machen 0 Probleme.

Bugs sind mir ein paar bekannt, z.B. wenn ein Label ganz am Anfang steht, kommt der Assembler nicht drauf klar stattdessen #0 schreiben. Auch kann mit "db" zurzeit nur 2 Einträge gleichzeitig definiert werden. "db 5,6" schreibt 5 und 6 in zwei aufeinanderfolgende Speicherzellen. "db 5,6,7" ignoriert die 7.

Ein Beispielprogramm:

Code:

push var1
push var2
add
pop var1
push var1
pop #7000
jmple #0
var1:
db 0
var2:
db 5

Das Programm addiert immer weiter 5 auf var1 (also 5, 10, 15...) schreibt das ganze dann in Adresse 7000, was dazu führt dass ein Pixel beschrieben wird (RRRGGGBB Format).

Baustelle ist zurzeit das Design. Bootstrap will nicht so wie ich will, und mobil sieht das ganze leider sehr bescheiden aus. Wenn sich einer Webdesign auskennt, ich nehme Tipps gerne an. Bezüglich Webdesign benutze ich nur Bootstrap internals, also kein externes Style CSS. Die Skripte sind zurzeit in die Webseite integriert, werden aber später ausgelagert. Wahrscheinlich werde ich auch noch den Programm Counter in den Memory Space Mappen, um vielleicht das Springe dynamischer zu machen.

FAQ:
Warum?
->Wollte schon immer mein eigenes Brainfuck

Die Testseite:
http://185.177.21.162/style.html

Wer sich traut damit mal für 2 Minuten rumzuspielen oder wer mir helfen will, dass Webdesign auch auf kleinen Bildschirmen zum laufen zu kriegen, kann ja hier mal seinen Senf reinschreiben.

[Chrisse]

Äußerst cool. Habe mal nen simplistisches Programm geschrieben, was den ersten Pixel durch alle Farben jagt:

Code:

push #6991
push one
add
pop #6991
push one
push zero
jmple #0
one:
db 1
zero:
db 0

Ein paar Anmerkungen:

Zitat:[0-9a-zA-Z]*: -> Label
#[0-9]* -> Absolute Adresse

Sollte wahrscheinlich

Zitat:[0-9a-zA-Z]+: -> Label
#[0-9]+ -> Absolute Adresse

sein, oder?

Der Assembler beschwert sich nicht über undefinierte Labels

Eine Tabelle die Instructions auf ihre Darstellung im Speicher mappt wäre hilfreich, damit ich beim debuggen auch sehe welche Instruction sich grad am Program Counter befindet.

[DosAmp]

Ich wollte ein Regenbogen-Programm schreiben, welches "richtig" durch verschiedene Farben iteriert, aber ich glaube die Stacktiefe von 8 Werten reicht dafür nicht aus, um allein die Funktion, die einen Farbwert im Bereich [0…1) bzw. [0…360°) bzw. [0…255] nach RGB umrechnet, mit 8-Bit-Integer- statt Fließkomma-Arithmetrik zu schreiben. Notfalls kann man auch sicher eine Lookup-Tabelle mit 256 Einträgen bauen.

Code:

/* konvertiert einen Farbwert im HSV-Farbraum bei maximaler Sättigkeit/Helligkeit
* in eine RGB8-Repräsentation (RRRGGGBB) von Stack8 */
unsigned char hue_to_rgb(unsigned char hue) {
    double huef, fracang, a, a1;
    int r, g, b;
    int side;

    /* auf Winkel 0° <= a < 360° skalieren */
    huef = 360.0 / 256.0 * hue;
    /* welche Seite des RGB-Würfels */
    fracang = huef / 60.0;
    side = (int) fracang;
    /* Winkel innerhalb der Würfelseite */
    a = fracang - side;
    /* komplementärer Winkel */
    a1 = 1.0 - a;

    /* RGB als einzelne Komponenten berechnen */
    switch (side) {
    default:
    case 0:
        r = 7;
        /* g <= 7 da kein exakter 60°-Winkel */
        g = 8 * a;
        b = 0;
        break;
    case 1:
        /* r <= 7 da kein exakter 60°-Winkel */
        r = 8 * a1;
        g = 7;
        b = 0;
        break;
    case 2:
        r = 0;
        g = 7;
        /* b <= 3 da side == 3 für exakten 180°-Winkel */
        b = 4 * a;
        break;
    case 3:
        r = 0;
        g = 8 * a1;
        /* je nach Compiler ist a1 == 1.0 für hue == 180 */
        if (g >= 8) {
            g = 7;
        }
        b = 3;
        break;
    case 4:
        /* r <= 7 da kein exakter 300°-Winkel */
        r = 8 * a;
        g = 0;
        b = 3;
        break;
    case 5:
        r = 7;
        g = 0;
        /* b <= 3 da kein exakter 300°-Winkel */
        b = 4 * a1;
        break;
    }
    return (r << 5) + (g << 2) + b;
}

unsigned char extract_red(unsigned char rgb) {
    return rgb & 0xe0;
}

unsigned char extract_green(unsigned char rgb) {
    return (rgb & 0x1c) << 3;
}

unsigned char extract_blue(unsigned char rgb) {
    return (rgb & 0x03) << 6;
}

Dabei skaliert immer nur ein Farbkanal innerhalb einer 60°-Drehung (bzw. einem Wertebereich von 42,666…) von Maximum zu 0 bzw. umgekehrt.

Dann könnte man so ein Programm schreiben:


So sähe im Übrigen die Lookup-Tabelle mit allen 256 Werten aus:

Code:

db 224,224
db 224,224
db 224,224
db 228,228
db 228,228
db 228,232
db 232,232
db 232,232
db 236,236
db 236,236
db 236,236
db 240,240
db 240,240
db 240,244
db 244,244
db 244,244
db 248,248
db 248,248
db 248,248
db 252,252
db 252,252
db 252,252
db 252,252
db 252,252
db 252,220
db 220,220
db 220,220
db 188,188
db 188,188
db 188,156
db 156,156
db 156,156
db 156,124
db 124,124
db 124,124
db 92,92
db 92,92
db 92,60
db 60,60
db 60,60
db 60,28
db 28,28
db 28,28
db 28,28
db 28,28
db 28,28
db 28,28
db 28,28
db 29,29
db 29,29
db 29,29
db 29,29
db 29,29
db 29,30
db 30,30
db 30,30
db 30,30
db 30,30
db 30,30
db 31,31
db 31,31
db 31,31
db 31,31
db 31,31
db 31,31
db 31,31
db 31,31
db 27,27
db 27,27
db 27,23
db 23,23
db 23,23
db 23,19
db 19,19
db 19,19
db 15,15
db 15,15
db 15,11
db 11,11
db 11,11
db 11,7
db 7,7
db 7,7
db 3,3
db 3,3
db 3,3
db 3,3
db 3,3
db 35,35
db 35,35
db 35,35
db 67,67
db 67,67
db 67,99
db 99,99
db 99,99
db 131,131
db 131,131
db 131,131
db 163,163
db 163,163
db 163,195
db 195,195
db 195,195
db 227,227
db 227,227
db 227,227
db 227,227
db 227,227
db 227,227
db 227,227
db 227,227
db 227,226
db 226,226
db 226,226
db 226,226
db 226,226
db 226,225
db 225,225
db 225,225
db 225,225
db 225,225
db 225,225
db 224,224
db 224,224
db 224,224
db 224,224
db 224,224

[Der Doktor]

(25.11.2017 16:56)DosAmp schrieb:  SNIP

Imho ist der beste Weg dafür, sich irgendwo Platz zu reservieren um dann temporär Werte dahin auszulagern. Genau wie bei 32-Bit x86, wo nicht alles in EAX,EBX,ECX und EDX passt.

Wenn ich heute pushi und popi implementiere kann man das ganze auch kompakter schreiben, indem man sich eine schöne Loop baut, die den Pointer zum Screen inkrementiert. Man muss nur das Carry beachten, bzw. selber berechnen.

Den LeftShift wollte ich vielleicht rauswerfen, um ihn stattdessen durch ein jmple (unsigned) zu ersetzen. Bin aber noch am überlegen, ob ich das mache oder nicht. Vielleicht kann man mit Tricks signed comparison mit einer unsigned operation machen. Bin da für Vorschläge offen. Man könnte natürlich Add rauswerfen, da man es per NAND synthesieren kann, aber so böse bin dann auch nicht. Ein bisschen Komfort muss sein.

Als Guide, wie man aus Nand und Add alles zusammenbauen kann übrigens:
http://bisqwit.iki.fi/story/howto/bitmath/
https://en.wikipedia.org/wiki/NAND_logic

Ich kann man mich ja mal an deinem Programm versuchen, ob ich es hinkriege. Wäre ein geiles Beispielprogramm. Denke mit ein bisschen reservierten Speicher kriegt man das hin. Sonst notfalls die Stacktiefe erhöhen

---

(25.11.2017 09:19)Chrisse schrieb:  SNIP

Ja die Regex hab ich gestern Abend hier schnell reingehauen, hab die nicht überprüft, aber kann das editieren.

Der Assembler sollte sich über nicht vorhandene Labels beschweren, aber das wird in die Konsole geloggt und noch nicht auf der Webseite angezeigt. Außerdem sagt er dir noch nicht, welches Label er nicht findet. Aber das steht auf der TODO Liste.
Der zweite Vorschlag klingt auch gut, sicherlich realisierbar, da ich die Instruktion ja sowieso dekodiere.

[Der Doktor]

Okay ich habe heute wieder rumgebastelt und das Update sollte die Qualität des Codens ziemlich verbessern.

Neu:
Zeilennummern:
Damit das ganze ein bisschen schöner aussieht

Assemblerwarnungen:
Wenn ihr Blödsinn macht, sagt euch der Assembler jetzt auf der Webseite, was ihm nicht passt. Zurzeit per alert(blabla).

Label Offsets:
Ihr deklariert beispielsweise "var: db 0,5" aber wie kommt man jetzt an die 5? Man kann jetzt statische Offsets deklarieren z.B. "push var+1", das heißt man geht von der Adresse von var (im Beispiel zeigt sie auf 0) zur nächsten. Ohne Limitierung.
Bald wird man auch mehr als 2 Einträge deklarieren können.

Neue Instructions:
Neu hinzugekommen:

Code:

pushi -> pusht Inhalt des Pointers in der absoluten Adresse auf den Stack
popi ->pusht den obersten Eintrag auf den Stack in die Adresse, auf die der Pointer zeigt, der an der absoluten Adresse liegt
---
Pseudoinstruktionen:
[0-9a-zA-Z]+(\+[0-9]+)? : Label (+ Offset in Dezimal)
dp : Sagt dem Assembler hier soll ein einzelner(!) Pointer abgelegt werden. Zwei Bytepositionen werden beschrieben. Pointersize = 13 Bit

Bugfixes:
Ein Label kann jetzt auch am Start stehen, dass macht keine Probleme mehr

Allgemeine Info:
Das Instruktionsformat ist wie folgt:
Opcode 3 Bit | 13 Bit Absolute Adresse/ignoriert
Alle Instruktionen sind 2 Byte groß. 8KB können mit 13 Bit adressiert werden. Daher sind DB Instruktionen zurzeit auch nur auf 2 Einträge beschränkt.

Wieder ein kleines Beispielprogramm:

Code:

start:
push tmp
push toAdd
add
pop tmp
push tmp
popi screen
push toAdd+1
push screen+1
add
pop screen+1
jmple start
tmp:
db 0
toAdd:
db 5,1
screen:
dp 6991

Was macht das Programm? In einer Endlosschleife wird ein Wert immer um 5 inkrementiert, dann wird das ganze über einen indirekten pop auf den Screen geschrieben. Danach hole ich mir die unteren 8 Bit der Screenadresse und inkrementiere sie um 1. Somit wird im nächsten Durchlauf ein anderes Pixel beschrieben. Naja, bis die unteren 8 Bit überlaufen. Ein Add+Carry muss man sich selber bauen (siehe meine Links weiter oben), was aber einfach ist. Quasi eine Krüppelversion von DosAmps Programm. Aber wir kommen der Sache schon näher . Die Lookup Table Version sollte sich jetzt mit ein paar Tricks (Add+Carry) gut implementieren lassen. Ich will aber das richtige Regenbogenprogramm zum Laufen kriegen .

Morgen setze ich mich weiter ran, vielleicht implementiere ich den Debugging Vorschlag von Chrisse. Wahrscheinlich setze ich mich aber morgen erstmal an die Share Funktion, damit man Programme speichern kann. Würde das eigentlich nicht machen, muss aber laut Vorgabe eine Datenbank benutzen .

Ich lade wieder alle ein das Ding mal für 5 Minuten auszutesten . Freue mich über jedes Programm .

http://185.177.21.162/style.html <-- Hier geht der Spaß los

Firefox und Chrome approved.

---

Zusammengebaute Instruktionen - Bibliothek
Hier ist eine kleine Liste von Instruktionen, die ich schon synthetisiert habe. Zum Copy-Pasten, damit es bei euch ein bisschen schneller geht. Da der LeftShift wahrscheinlich morgen rausgekickt wird und um eine unsigned jmple Variante ersetzt wird, habe ich ihn auch schon in die Liste aufgenommen. Die Operationen enthalten Beispielzahlen

Spoiler anzeigen

Code:

NOT:

push x
push x
nand
x:
db 0
----
AND:

push x
push y
nand
push x
push y
nand
nand
x:
db 5
y:
db 7
----
OR:

push x
push x
nand
push y
push y
nand
nand
x:
db 5
y:
db 7
----
NOR:

push x
push x
nand
push y
push y
nand
nand
pop z
push z
push z
nand
x:
db 5
y:
db 7
z:
db 0
----
XOR:

push x
push y
nand
pop z
push x
push z
nand
push y
push z
nand
nand
x:
db 5
y:
db 7
z:
db 0
----
XNOR:

push x
push x
nand
push y
push y
nand
nand
push x
push y
nand
nand
x:
db 5
y:
db 7
----
NEG/2er Kompliment:

push x
push x
nand
push one
add
x:
db 5
one:
db 1
----
SUB:

push y
push y
nand
push one
add
push x
add
x:
db 7
y:
db 5
one:
db 1
----
TEST SIGN:

push toTest
push signMask
nand
push toTest
push signMask
nand
nand
push signMask
add
push zero
jmple isNegative
push itIsPositive //code is executed when positive
isNegative:
push itIsNegative //code is executed when negative
toTest:
db 130
signMask:
db 128
zero:
db 0
itIsPositive:
db 42
itIsNegative:
db 24
----
LEFT SHIFT BY 1:

push x
push x
add
x:
db 5
----

[Der Doktor]

Nochmal ein kleines Update meinerseits für diejenige die es interessiert...

Habe die Seite und die VM nochmal geändert und aufgemotzt. Die Run-Funktion läuft jetzt schneller. Außerdem ist lfsh rausgeflogen und wurde um jump on unsigned less or equal jmpule ersetzt. Außerdem habe ich einen Bug beseitigt, bei dem leere Zeilen die Labelauflösung behindern.

Außerdem ist jetzt möglich Programme zu teilen und fremde Programm über einen Mausklick zu laden.
Share: http://185.177.21.162/community.php

Habe zwei Programme schon abgespeichert. Darunter eine Programm, was den ganzen Screen mit allen Farben füllt.

[Der Doktor]

Nach meiner kurzen Exkursion in meine Stack8 VM, bin ich seit Anfang des Jahres wieder beim ursprünglichen Thema. Nachdem ich mir ein größeres Breadboard besorgt habe, um die grundlegende Schaltung aufzubauen, sowie eine Hand voll verschiedener 74xx ICs kann ich weiter an den Ausbau gehen.

Dazu habe ich meine Schaltung vom August komplett abgebaut, und auf dem größeren Breadboard neu angefangen. Der Platz sollte für einen sehr einfachen Z80 Rechner reichen, der auf ROM/RAM zugreifen kann.

Um den Load auf die CPU möglichst gering zu halten, wandern alle Adressleitungen und später auch alle Datenleitungen durch einen Buffer, der die CPU mit der Außenwelt verbindet. Die Adressleitungen sind dauerhaft durchgeschaltet, der Buffer für die Datenleitung wird je nach dem ob gelesen wird oder geschrieben wird, die eine oder andere Seite durchlassen.

Zurzeit sind schon alle Adressleitungen an den Buffer angebunden. Da die Adressleitungen leider nicht so schön liegen, sieht das ganze etwas chaotisch aus. Die Datenleitungen sind immer noch auf dauerhaft 0x00 (NOP) geschaltet. Unter den Buffer habe ich auch einen Decoder aufgebaut, der entscheidet, ob es RAM oder ROM sein darf. Ich habe mich für einen einfachen 32K/32K Split entschieden.

Bilder (Achtung große Auflösung):
Ohne Beschriftung

Spoiler anzeigen

Mit Beschriftung

Spoiler anzeigen

Desweiteren habe ich mir einen Arduino Mega Klon angeschafft. In einer ziemlich hässlichen Schaltung benutze ich ihn um eine EEPROM zu programmieren. Den Code zum Auslesen und Schreiben habe ich dabei "schnell" selber geschrieben. Kleinere Probleme gab es, da die Arduino Pins beim Anschalten kurz in einem undefinierten Zustand sind, wurden mir auch immer random werte beim Start reingeschrieben. Wenn die EEPROM aber später erst dazu geschaltet wird läuft alles rund.
Zurzeit habe ich das Programm "NOP;NOP;NOP;NOP;HALT" reingeschrieben, um später die Funktionalität zu prüfen.

Mehr später.

[Der Doktor]

Der Z80 ist jetzt endlich am laufen...

Über die letzten zwei Wochen habe ich einen 555 Timer installiert, der mit unglaublichen 14 Hz den Z80 antreibt. Also ist der Z80 jetzt unabhängig und braucht keinen Arduino mehr zum starten.
Hinter den Adressbuffern habe ich die EEPROM (zurzeit nur 8k, später 32k) und den 32k SRAM installiert. Das Memory Layout ist also 50:50.

Weil die Pins an den ICs leider nicht so angeordnet sind, dass ich schöne Schaltungen bauen kann, gehen die Steckbrücken jetzt quasi kreuz und quer. Eigentlich wollte ich alles farbkodieren, aber mit den vorgefertigten Steckbrücken geht das schwer. Dazu bräuchte ich ne Kabelrolle, wo ich mir die richtigen Längen abschneiden kann. Aber ich blicke da tatsächlich noch durch.
Das größte Chaos herrscht über der EEPROM, weil die Leitungen A0 bis A4 auch irgendwie zum SRAM müssen. Und Leitungen A8-A12 zur EEPROM. Die ungenutzten Eingänge vom Adressbuffer habe ich auch genutzt um die Read und Write Enable Line zu puffern.
Der Datenbus besteht aus flexiblen Kabeln, die die Daten auf die andere Seite übertragen.

Dort habe ich einen Datenbuffer aufgebaut, der immer nur eine Richtung durchlässt, je nachdem ob ein Read oder Write durchgeführt werden soll.

Um direkt alle Teile des Systems zu testen habe ich ein kleines Program geschrieben, was erstmal 32 NOPs ausführt und dann HL mit 0x8000 (erste RAM Adresse) lädt und dann den Wert 42 dort speichert. Danach wird auf die Zelle zugegriffen und der Wert im Akkumulator gespeichert. Anschließend wird der Wert über die OUT Anweisung an eine I/O Adresse geschickt und danach gehalten.

Um den Wert abzufangen hängt der Arduino an der IOREQ Line und wartet auf die I/O Anweisung, dann greift er die Daten ab und schickt sie über Serial an meinen Computer. Quasi eine sehr primitive Parallel/Serial.

Spoiler anzeigen

Das nächste Ziel ist es, das ganze jetzt auf eine Prototyp Platine zu löten. Dann kann ich auch eine eigene UART anschließen usw. . Aber zuerst steht noch ein Vortrag an, wo ich das Setup gerne nutzen würde um einen kryptographischen Angriff zu demonstrieren. Dazu schreibe ich am Wochenende das Programm.

[Blue]

Gibts da eigentlich was von Ratiopharm guten Lehrbüchern?

Würd mich auch gern mal damit beschäftigen, ne CPU krieg ich auch auf ne Lochrasterplantine gelötet, allerdings wüsste ich gar nicht was ich dazu noch alles bräuchte (und jetzt alles 1:1 nachbauen von dir, wär ja nich sinn der Sache).

Hat eben nachm ATTiny geschaut, schön 8pin, bissel zum rumtüddeln, vll mal externen SRAM ansteuern, ja. Allerdings scheint das auch alles für mich aktuell Magie zu sein. Dann nach 8085 geschaut und bissel IC Krams dazu, aber da fehlt mir einfach das Wissen und wtf 12 Euro für ne CPU. Dann lieber ein ATTiny für 2 Euro. Aber da brauch ich wieder nen Programmer (hab nurn LPT-Programmer von 1998 mit Support bis 2003?, für den EEPROM der dann an ner 8085 hängen würde, sicherlich noch neu genug.. aber lol)

Wie ich das nachher "Programmiere" is wiederrum, qualvoll machen. Sonst lerne ich es nie.

Aber ich bin zwar Elektriker, aber wenn ich hier schon begriffe wie Buffer lese, was ich nur aus der Software kenne, dann bin ich schon aufgeschmissen.

Was würdest du Wortwörtlich ein Nix-Könner jetzt empfehlen? Du kennst mich, ich wills gleich dreckig. Volle Dröhnung, irgendwas lustiges.