Correct, translate and new cover picture on FreeDOS Post.

content/blog/freedos/index.en.md

@@ -0,0 +1,69 @@
+---
+title: "FreeDOS 🐳"
+date: 2022-02-26T20:06:36+01:00
+draft: false
+hideLastModified: true
+summaryImage: "img/freedos.webp"
+keepImageRatio: true
+summary: "A little play with FreeDOS. And an illustration of how easy it is to access the hardware directly."
+showInMenu: false
+tags: [""]
+---
+
+FreeDOS is an open-source operating system designed to be compatible with MS-DOS.
+It was mainly developed to run old programs and games on modern hardware.
+Exploring these older systems offers a fascinating glimpse into the history of operating systems,
+especially when we realize how many mechanisms we take for granted today simply didn’t exist back then.
+
+I’m not even talking about graphical user interfaces but rather basic security principles.
+For example, DOS systems lack the separation between kernel space and user space,
+which is a core feature of modern operating systems.
+This separation, often referred to as privilege levels or ring architecture,
+ensures stability and security by preventing unauthorized access.
+
+## What Are Privilege Levels?
+
+Modern operating systems use a ring architecture that defines different privilege levels for running code. These levels range from Ring 0 (Kernel Mode) to Ring 3 (User Mode):
+
+- **Ring 0** (Kernel Mode): This is where the OS kernel runs, with direct access to the hardware. Programs running in this mode have complete control over the system, making security crucial.
+- **Ring 3** (User Mode): Regular programs and applications run here. They can’t directly access the hardware and must make requests through the kernel, which helps secure the system.
+
+In contrast, FreeDOS operates without this separation. Every process can access hardware directly, which offers flexibility but also presents security risks.
+
+## QBasic and the Parallel Port
+
+One interesting example of how easy hardware access used to be is working with the parallel port. I found a great [Youtube Video](https://www.youtube.com/watch?v=7D-JES4BnTw) that demonstrates how to control the parallel port with basic QBasic code.
+
+Nowadays, accessing hardware directly without special permissions or drivers would be unthinkable. But with FreeDOS, it’s very straightforward.
+
+Here’s a guide on how to control the parallel port using FreeDOS and QBasic:
+
+1. Use Rufus to copy FreeDOS onto a USB stick.
+2. Download [QBasic](https://www.qbasic.net/de/qbasic-downloads/compiler/qbasic-compiler.htm) (Version 7.1) and place it on the USB stick.
+3. Boot the target system from the USB stick.
+4. Navigate to the QBasic directory: `cd bin`
+5. Start QBasic: `qbx`
+
+Here’s a small program that counts from 1 to 255 and sends the number
+to the parallel port in binary form while also displaying it on the screen:
+
+{{< codeWide >}} 
+FOR COUNT = 0 TO 255 STEP 1
+OUT 888, COUNT 
+PRINT "Number: ", COUNT 
+SLEEP 1 
+NEXT COUNT 
+{{< /codeWide >}}
+
+![Photo of the QBasic code](img/qbasic.jpg)
+
+The number `888` corresponds to the parallel port.
+The setup involves connecting the parallel port’s data lines to the positive end of LEDs. All LEDs are connected to the parallel port’s `GND`.
+
+Here are two photos of the setup:
+
+![Shows a motherboard with USB stick and LEDs near the parallel port](img/aufbau.jpg) | ![Close-up of the LEDs](img/aufbau2.jpg)
+
+And here’s a short video showing the counting process:
+
+[![Video shows the setup with counting computer](img/thump.png)](img/working.mp4)

content/blog/freedos/index.md

@@ -3,47 +3,76 @@ title: "FreeDOS 🐳"
 date: 2022-02-26T20:06:36+01:00
 draft: false
 hideLastModified: true
-summaryImage: "img/FreeDOS.jpg"
+summaryImage: "img/freedos.webp"
 keepImageRatio: true
-summary: "Eine kleine spielerei mit FreeDOS. Und Verdeutlichung wie einfach es ist direkt auf die Hardware zuzugreifen."
+summary: "Ein Blick auf FreeDOS. Verdeutlicht wie einfach es ist direkt auf die Hardware zuzugreifen."
 showInMenu: false
 tags: [""]
 ---
 
-Ich möchte kurz mal ein Wort über FreeDOS verlieren. Es ist ein Betriebsystem, dass die Kompatibilität zu MS-DOS schaffen möchte.
-Grundidee ist es, alte Programm haupsächlich Spiele wieder zu laufen zu bekommen.
-Ich finde es recht interessant, wenn man mal in die Vergangenheit der Betriebssystem gucken kann. Und man merkt, dass viele der Mechanismen, die wir von einem Betriebssystem gewohnt sind, einfach nicht existieren.
-Ich spreche da nicht mal von einer GUI, ich meine auch Prinzipien, die mein System absichern.
+FreeDOS ist ein Open-Source-Betriebssystem, das Kompatibilität mit MS-DOS herstellen soll.
+Es wurde hauptsächlich entwickelt, um alte Programme und Spiele auf moderner Hardware zum Laufen zu bringen.
+Besonders interessant ist es, in die Vergangenheit der Betriebssysteme zu schauen und zu merken,
+wie viele Mechanismen, die wir heute als selbstverständlich erachten, damals einfach nicht existierten.
 
-Ich habe ein cooles Video gefunden, dass zeigt, wie man mit simplen QBasic den Parallel Port des Computers steuern kann. [Link zum Video auf YouTube](https://www.youtube.com/watch?v=7D-JES4BnTw)
+Hierbei rede ich nicht einmal von grafischen Benutzeroberflächen,
+sondern von grundlegenden Sicherheitsprinzipien. 
+Zum Beispiel existiert bei DOS-Systemen keine Trennung von Kernel- und Userspace, wie sie in modernen Betriebssystemen üblich ist.
+Diese Trennung, auch als Privilegienstufen oder Ringarchitektur bekannt, schützt moderne Systeme vor schädlichen Zugriffen und sorgt für Stabilität.
 
-Ich denke mal, das wäre heute undenkbar und nur mit erheblichen Aufwand zu bewerkstelligen.
-Eine Hierarchie mit Kernel und Userspace gab es einfach noch nicht.
+## Was sind Privilegienstufen?
 
-Aber ich wollte mal gucken, ob es wirklich so einfach ist, mit FreeDOS dieses Ziel zu erreichen und stellt sich raus, ´das ist es. 😜
+Moderne Betriebssysteme verwenden eine sogenannte Ringarchitektur, die unterschiedliche Privilegienstufen für die Ausführung von Code definiert.
+Diese Ringe reichen von Ring 0 (Kernel-Mode) bis zu Ring 3 (User-Mode):
 
+- **Ring 0** (Kernel-Mode): Hier läuft der Betriebssystemkernel, der direkten Zugriff auf die Hardware hat.
+Programme in diesem Modus können alles auf dem System steuern, weshalb sie besonders gut abgesichert sein müssen.
+- **Ring 3** (User-Mode): Hier laufen gewöhnliche Programme und Anwendungen.
+Sie haben keinen direkten Zugriff auf die Hardware, sondern müssen Anfragen über den Kernel stellen.
+Dadurch wird die Sicherheit des Systems erhöht.
 
-Einfach mit Rufus FreeDos auf einen Stick ziehen, dann noch [QBasic](https://www.qbasic.net/de/qbasic-downloads/compiler/qbasic-compiler.htm) in Version 7.1 daneben kopieren.
+Im Gegensatz dazu läuft bei FreeDOS alles ohne diese Trennung.
+Jeder Prozess kann direkt auf die Hardware zugreifen, was zwar flexibel ist, aber auch Sicherheitsrisiken birgt.
 
-Dann auf dem Zielsystem vom USB-Stick booten und ins QBasic Verzeichnis wechseln: `cd bin`
+## QBasic und der Parallelport
 
-Und dann QBasic starten: `qbx`
+Ein interessantes Beispiel dafür, wie einfach es früher war, auf die Hardware zuzugreifen,
+ist der Umgang mit dem Parallelport.
+Ich habe ein cooles [Youtube Video](https://www.youtube.com/watch?v=7D-JES4BnTw) gefunden, das zeigt,
+wie man mit einfachem QBasic den Parallelport steuern kann.
 
-Folgendes Mini Programm, zählt von 1 bis 255 und gibt die Zahl auf dem Monitor sowie in Binärer Zählweise auf der Parallele Schnittstelle aus.
+Heutzutage wäre es undenkbar, ohne spezielle Berechtigungen oder Treiber direkt auf die Hardware zuzugreifen.
+Doch bei FreeDOS ist das ganz einfach.
 
-Das folgende Bild zeigt mein Programm:
+Hier eine Anleitung, wie du mit FreeDOS und QBasic den Parallelport steuern kannst:
 
-![Foto vom QBasic Code ](img/qbasic.jpg)
+1. Mit Rufus FreeDOS auf einen USB-Stick kopieren.
+2. [QBasic](https://www.qbasic.net/de/qbasic-downloads/compiler/qbasic-compiler.htm) (Version 7.1) herunterladen  und auf den Stick packen.
+3. Das Zielsystem vom USB-Stick booten.
+4. Ins QBasic-Verzeichnis wechseln: `cd bin`
+5. QBasic starten: `qbx`
 
-Die `888` bei dem `OUT` Befehl bedeutet, dass es sich hierbei um den Parallelport handelt.
+Hier ein kleines Programm, das von 1 bis 255 zählt und die Zahl sowohl auf dem Bildschirm
+als auch über den Parallelport in binärer Form ausgibt:
 
-Hier zwei Fotos des Aufbaues:
+{{< codeWide >}}
+FOR COUNT = 0 TO 255 STEP 1
+OUT 888, COUNT
+PRINT "Number: ", COUNT
+SLEEP 1
+NEXT COUNT
+{{< /codeWide >}}
+
+![Foto vom QBasic Code](img/qbasic.jpg)
 
-![Zeigt ein Mainboard mit USB-Stick und LEDs vor dem Parallel Port](img/aufbau.jpg) | ![Zeigt die LEDs genauer](img/aufbau2.jpg)
+Die `888` steht für den Parallelport.
+Der Aufbau sieht so aus: Jumper verbinden die Datenleitungen des Parallelports mit dem positiven Ende einer LED. 
+Alle LEDs sind mit `GND` vom Parallelport verbunden.
+
+Hier zwei Fotos des Aufbaues:
 
-Die Jumper gehen in die Data Leitungen des Parallel Ports, diese sind dann mit dem positiven Ende einer LED verbunden.
-Als letztes müssen alle LEDs noch mit `GND` verbunden werden, dieser kommt auch aus dem Parallel Port.
+![Zeigt ein Mainboard mit USB-Stick und LEDs vor dem Parallelport](img/aufbau.jpg) | ![Nahaufnahme der LEDs](img/aufbau2.jpg)
 
-Hier ein kleines Video:
+Und hier ein kurzes Video, das den Zählvorgang zeigt:
 
 [![Video zeigt den Aufbau mit Zählendem Computer](img/thump.png)](img/working.mp4)