#retro programmierung

[basic-retro-programming]

Programmieren in Basic: Computergeschichte

Post #309: Heimcomputermuseum.de, Programmieren in Basic, Ein Streifzug durch die Computergeschichte, 2024.

[basic-retro-programming]

Post #346: Thomas Eugene Kurtz (22.2.1928 - 12.11.2024), Mathematician & Information Sciencist, One of the inventors of the BASIC programming language, 2025.

RIP Dr. Thomas Kurtz - inventor of the BASIC programming language that became widely used in the 1970s and 80s for programming minicomputer and home computer systems.

BASIC made computer programming accessible to a wide audience that included students, scientists and businesses due to its easy to understand syntax, immediately runnable code, and widespread availability. My earliest explorations of the software world involved writing BASIC programs, and I'm very grateful for Dr. Kurtz's contributions to the world of computing.

[draegerit]

PS/2 Tastatur auslesen mit Arduino: Deine Schritt-für-Schritt-Lösung

In Zeiten von USB und Bluetooth sind alte PS/2-Tastaturen längst aus unserem Alltag verschwunden, doch mit ein wenig Technik-Know-how kannst du sie für spannende Projekte wiederbeleben. In diesem Beitrag zeige ich dir, wie du eine PS/2-Tastatur an deinen Arduino anschließt und die Signale ganz einfach auslesen kannst. Wir starten damit, den Aufbau des PS/2-Steckers und der Buchse zu verstehen – das ist der erste Schritt, um die Verbindung richtig herzustellen. Mit der Arduino IDE wird das Auslesen der Tastaturdaten kinderleicht. Später gehen wir noch einen Schritt weiter und nutzen die Tastatur, um automatische Aktionen auszulösen – perfekt für Makros oder Steuerungsaufgaben. Lass uns loslegen und deine Retro-Hardware wieder zum Leben erwecken! https://youtu.be/6isSYB9LYW4 Die Idee zu diesem Beitrag habe ich einem meiner Follower zu verdanken, der meinen bereits veröffentlichten Beitrag zum MacroPad gesehen und die spannende Frage gestellt hat, ob man ein solches Projekt nicht um eine PS/2-Tastatur erweitern könnte. Vielen Dank für die tolle Anregung! Eure Fragen und Ideen inspirieren mich immer wieder zu neuen Projekten und zeigen, wie vielfältig und kreativ die Maker-Community ist.

Aufbau einer PS/2 Buchse

Damit deine PS/2-Tastatur mit dem Arduino spricht, musst du wissen, wie die Pins der PS/2-Buchse belegt sind. Auf dem Bild siehst du das Pinout, und es wird direkt klar: Du brauchst nur vier Pins! Zwei davon sind für die Stromversorgung (VCC und GND) zuständig, die anderen beiden für die Kommunikation (Clock und Data).

Ein kleiner, aber wichtiger Hinweis: Wenn du direkt die Pins vom Stecker abgreifen willst, ist das Pinout spiegelverkehrt! Also achte gut darauf, dass alles richtig verbunden ist. Sobald das passt, bist du nur noch ein paar Schritte davon entfernt, Daten mit deinem Arduino auszulesen. So einfach kann’s gehen!

Bezug einer PS/2 Buchse

Du bekommst PS/2 Buchsen & Stecker immer noch zu kaufen, auch wenn diese bereits seit mehreren Jahren durch den USB-Standard abgelöst wurden. Nachfolgend gebe ich dir ein paar Links zu dem hier verwendeten Modul. ebay.dealiexpress.comBuchse auf Platineab 1,67 €*1,39 €Buchse einzelnab 2,82 €*2,05 € Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Schaltung am Arduino UNO R3

Es gibt die PS/2 Buchsen einzeln als Baustein für den Aufbau auf einer Lochrasterplatine und auch als Modul fertig auf einer Platine, ich habe mich für die letztere Version entschlossen, da dieses für den Beitrag erstmal völlig ausreicht und keinen nennenswerten Vorteil / Nachteil gibt.

PS/2 Keyboard Adapter am Arduino UNO R3

Auslesen einer PS/2 Tastatur am Arduino mit der Arduino IDE

Nachdem das kleine Modul angeschlossen und mit der Tastatur verbunden ist, können wir mit der Programmierung starten.

Wir können uns hier wie üblich mit einer passenden Bibliothek die Arbeit sehr einfach machen. Ich verwende die Bibliothek PS2Keyboard von Christian Weichel, welche du ganz bequem über den Bibliotheksverwalter der Arduino IDE installieren kannst.

Nachfolgend ein kleines Beispiel, welches auf der seriellen Schnittstelle die gedrückte Taste ausgibt. Dieses funktioniert für die Tasten 0-9 und a-z sehr zuverlässig. Möchtest du die Sonderzeichen und Großbuchstaben behandeln, so muss auch die Aktion an der Shift-Taste behandelt werden. //Bibliothek zum auslesen der KeyCodes einer PS/2 Tastatur #include //Pins #define dataPin 4 #define clkPin 3 //Initialisieren des Objektes PS2Keyboard keyboard; void setup() { //beginn der seriellen Kommunikation mit 115200 baud Serial.begin(115200); //beginn der Kommunikation mit der PS/2 Tastatur keyboard.begin(dataPin, clkPin); } void loop() { //Wenn Daten empfangen werden können, dann... if (keyboard.available()) { //auslesen des KeyCodes uint16_t c = keyboard.read(); //Wenn der Code größer 0 ist, dann... if (c > 0) { //umwandeln des Wertes in einen Charakter //damit wird die gedrückte Taste ausgegeben Serial.print(char(c)); //Dieses Funktioniert für die Taster 0-9 und a-z zuverlässig. //Möchtest du die Sonderzeichen und Großbuchstaben behandeln //so muss zuvor auf die Shift-Taste reagiert werden. } } }

Steuern eines Servomotors via PS/2 Tastatur

Wir können mit der Tastatur nun recht einfach einen Servomotor steuern, dazu verwende ich die beiden Pfeiltasten rechts & links.

Die kleine Schaltung erweitern wir hierzu um den Servomotor, welcher an einen digitalen PWM Pin angeschlossen wird. Einen solchen PWM Pin erkennen wir an der Tilde ~ an der Pinbeschriftung. BauteilArduino UNO R3PS/2 ModulCLK (grün)D4DATA (gelb)D3VCC (rot)5 VGND (schwarz)GNDServomotorVCC (rot)5 VGND (braun)GNDDATA (orange)D9 //Bibliothek zum ansteuern eines Servomotors am Arduino #include //Bibliothek zum auslesen der KeyCodes einer PS/2 Tastatur #include //Pins #define dataPin 4 #define clkPin 3 //Initialisieren des Objektes PS2Keyboard keyboard; //Servomotor am digitalen Pin D9 angeschlossen #define servoPin 9 //initialisieren des Servo-Objektes Servo servo; //Schritte für den Servomotor const int SERVO_STEPS = 10; //maximale & minimale Position des Servos const int MAX_SERVO_POSITION = 180; const int MIN_SERVO_POSITION = 0; //Feld zum speichern der aktuellen Servoposition unsigned int servoPosition = 0; void setup() { //beginn der seriellen Kommunikation mit 115200 baud Serial.begin(115200); //beginn der Kommunikation mit der PS/2 Tastatur keyboard.begin(dataPin, clkPin); //verbinden des Servo-Objektes mit dem Pin servo.attach(servoPin); //beim starten des Mikrocontrollers soll die NULL-Position angefahren werden servo.write(servoPosition); } void loop() { //Wenn Daten empfangen werden können, dann... if (keyboard.available()) { uint16_t c = keyboard.read(); //Wenn die Pfeiltaste Links & die aktuelle Servoposition kleiner als die maximale ist, dann... if (c == PS2_LEFTARROW && servoPosition //erhöhen der Servoposition um X Schritte servoPosition += SERVO_STEPS; //schreiben der aktuellen Position servo.write(servoPosition); } else if (c == PS2_RIGHTARROW && servoPosition > MIN_SERVO_POSITION) { servoPosition -= SERVO_STEPS; servo.write(servoPosition); } } } Read the full article

[games-und-lyrik]

AweKteaM: Die Meister hinter dem Tower Princess

AweKteaM entwickelte das Game Tower Princess. Bevor wir uns in die märchenhafte Welt von "Tower Princess" vertiefen, lass uns einen genaueren Blick auf die kreativen Köpfe werfen, die dieses beeindruckende Spiel geschaffen haben. Hier dreht sich alles um die Entwickler, die mit Leidenschaft und Hingabe daran arbeiten, Spieler wie dich in ihren Bann zu ziehen. ©AweKteaM. Awekteam: Eine Leidenschaft für Spiele Es handelt sich um ein unabhängiges Entwicklerteam aus Deutschland, das sich auf die Schaffung einzigartiger und fesselnder Spiele spezialisiert hat. Ihre Mission? Spiele zu kreieren, die nicht nur unterhalten, sondern auch eine tiefe Verbindung zwischen Spielern und virtuellen Welten herstellen. Die Mitglieder teilen eine gemeinsame Leidenschaft für Gaming, und diese Leidenschaft spiegelt sich in jedem ihrer Projekte wider. https://youtu.be/Zu1ZT3tDy1M?si=1mpvot-2rY237TJt Die Entwicklungsreise von "Tower Princess" Die Entstehung von "Tower Princess" war für Awekteam eine aufregende und herausfordernde Reise. Sie begannen mit einer Idee und setzten dann ihre Fähigkeiten in der Programmierung und im Level-Design ein, um die Spielwelt zum Leben zu erwecken. Das Team arbeitete hart daran, eine fesselnde Spielerfahrung zu schaffen und dabei einen einzigartigen Retro-Stil beizubehalten, der an klassische Plattformspiele erinnert. ©AweKteaM. Hingabe an Qualität Was ihn von anderen Entwicklern abhebt, ist ihre Hingabe an Qualität und Innovation. Sie wollten sicherstellen, dass "Tower Princess" nicht nur ein weiteres Spiel ist, sondern ein unvergessliches Erlebnis für jeden Spieler. Mit interaktiven Umgebungen, vielfältigen Waffenoptionen und einem fesselnden Gameplay haben sie sichergestellt, dass "Tower Princess" sich von der Masse abhebt. ©AweKteaM. Dein Abenteuer beginnt Jetzt, da du mehr über die Entwickler hinter "Tower Princess" weißt, kannst du das Spiel mit einer ganz neuen Wertschätzung spielen. Du kannst die Leidenschaft und Hingabe von Awekteam in jedem Detail des Spiels spüren. Also, bereite dich darauf vor, dich in die zauberhafte Welt von "Tower Princess" zu stürzen und das Abenteuer zu genießen, das dieses talentierte Entwicklerteam für dich geschaffen hat. Viel Spaß beim Spielen! Weiter geht es zur Website des Games Lesen Sie den ganzen Artikel

[frentmeister]

Wie man Sicherheitstests für AngularJS mit Hilfe von OWASP ZAP durchführt

Schon 2018 hatte ich mich sehr umfassend mit dem Thema Voyager 1 und Voyager 2 beschäftigt. Dabei ging es um eine „fixe“ Idee, dass man das Board System welches Fortran beruht auf Python umswitcht. Ich habe in diesem Beitrag von 2018 dargelegt, wie die einzelnen Komponenten aufgebaut sind, wie man eventuell hier Python zum Einsatz bringen könnte. Aber nachhaltig auch festgestellt, dass ein Umstieg auf Python eventuell sogar schädlicher wäre.   https://www.dev-crowd.com/2018/12/22/retro-engineering-am-beispiel-voyager-1-und-voyager-2-mission/   Betrachtet man die Meldung bezüglich des „falschen Befehls“ der an Voyager 2 versendet wurde, so hätte man das in einer entsprechenden Emulation eigentlich feststellen müssen, dass eben dieser Befehl klar falsch ist. Bisher bin ich immer davon ausgegangen, dass so etwas in einer Emulation auf einem Environment stattfindet. Denn wie bei allen uns bekannten Sprachen, die man entsprechend einsetzt, gibt es entsprechende Testframeworks, die entsprechende Emulationen ausführen. Die Antenne von »Voyager 2« zeigt nicht mehr exakt zur Erde, der Kontakt ist dadurch unterbrochen. Der Grund: ein falscher Befehl. Doch im Oktober könnte die Kommunikation wieder aufgenommen werden. Quelle: https://www.spiegel.de/wissenschaft/nasa-verliert-kontakt-zu-sonde-voyager-2-wegen-eines-falschen-befehls-a-2c41883b-2e28-4413-a40b-075c59c10ce1 Hier eine weitere Meldung: Der Kontakt zu der Sonde war am 21. Juli 2023 abgebrochen, nachdem "eine Serie geplanter Befehle" an sie gesendet worden war. Die hatten dazu geführt, dass sich die Antenne um 2 Grad von der Erde wegdrehte, weshalb kein Kontakt mehr möglich war. Quelle: https://www.golem.de/news/raumfahrt-nasa-empfaengt-signal-von-voyager-2-2308-176370.html     Fortran spielte in den frühen Jahren der Raumfahrt und insbesondere bei der Entwicklung von Raumsonden eine wichtige Rolle. Das Voyager-Programm wurde in den 1970er Jahren gestartet, als Fortran immer noch eine der vorherrschenden Programmiersprachen für wissenschaftliche und technische Anwendungen war. Und Fortan wird bis heute gerade auch im wissenschaftlichen Umfeld immer noch genutzt! Welche Fortran Versionen gibt es? - Fortran I (1957): Die erste Version von Fortran wurde 1957 von IBM entwickelt. Sie wurde für den IBM 704 Computer entwickelt und war die erste höhere Programmiersprache überhaupt. Fortran I unterstützte die grundlegenden Konzepte der Programmierung, aber es gab noch keine Unterprogramme (keine Unterstützung für Unterprogramme wie Funktionen oder Subroutinen). - Fortran II (1958): Fortran II wurde 1958 veröffentlicht und fügte einige neue Funktionen hinzu, darunter Unterprogramme und die Möglichkeit, Unterprogramme in anderen Unterprogrammen aufzurufen. Es war eine verbesserte Version von Fortran I. - Fortran IV (1962): Fortran IV war eine weiter verbesserte Version von Fortran und wurde 1962 veröffentlicht. Es führte neue Funktionen wie logische Variablen, DO-Schleifen und FORMAT-Anweisungen ein, um die Ausgabe zu formatieren. - Fortran 66: Fortran 66, auch bekannt als Fortran IV oder Fortran 66 Standard, wurde 1966 eingeführt. Es war die erste offizielle Version der Sprache mit einem standardisierten Sprachumfang. Fortran 66 führte neue Funktionen wie das IF-THEN-ELSE-Konstrukt ein und standardisierte einige vorhandene Sprachkonstrukte. - Fortran 77: Fortran 77, auch bekannt als Fortran 1977 Standard, wurde 1977 veröffentlicht. Es war eine bedeutende Aktualisierung und erweiterte den Funktionsumfang von Fortran erheblich. Fortran 77 führte Zeichenkettenverarbeitung, dynamische Speicherzuweisung (mit der ALLOCATE-Anweisung) und verbesserte Array-Funktionen ein. - Fortran 90: Fortran 90 wurde 1991 veröffentlicht und brachte wichtige Erweiterungen in die Sprache. Es führte den freien Formatierungsstil ein, verbesserte die Array-Unterstützung (einschließlich dynamischer Arrays und Array-Schnittoperationen), fügte neue Sprachkonstrukte wie MODULES, POINTERs und DO WHILE-Schleifen hinzu und ermöglichte rekursive Unterprogramme. - Fortran 95: Fortran 95 wurde 1997 als geringfügige Aktualisierung von Fortran 90 veröffentlicht. Es behebt einige Unklarheiten und Fehler in Fortran 90 und fügt einige neue Funktionen hinzu, wie beispielsweise Verbesserungen bei der ALLOCATE-Anweisung und Unterstützung für den CHARACTER-Datentyp mit variabler Länge. - Fortran 2003, Fortran 2008, Fortran 2018: Diese Versionen sind weitere Erweiterungen von Fortran, die neue Funktionen und Verbesserungen in die Sprache einbringen, wie z. B. Verbesserungen bei der Behandlung von Zeichenketten, Verbesserungen bei der parallelen Programmierung (Fortran 2008) und viele andere Funktionen.  

Testframeworks für Fortran

In der Welt von Fortran gibt es mehrere Testframeworks, die verwendet werden können, um Unit-Tests für Fortran-Code durchzuführen. Wobei man sagen muss das Voyger 2 in Teilen noch auf Fortran 77 beruht aber auch Fortran 90.   Hier sind einige beliebte Testframeworks, es gibt aber weitaus mehr unter anderem entwickelt durch NASA Mitarbeiter: Testframework Details Weiterführende Informationen Alternative FRUIT (Fortran Unit Tester): FRUIT ist eines der ältesten Testframeworks für Fortran und wird häufig verwendet, um Unit-Tests für Fortran-77-Code zu schreiben. Es unterstützt die Erstellung von Testsuiten und Assertions, um die Funktionalität von Fortran-Routinen zu überprüfen. https://github.com/mortele/FRUIT FUnit FUnit ist ein moderneres Testframework für Fortran, das speziell für die Erstellung von Unit-Tests in Fortran entwickelt wurde. Es unterstützt Fortran 90 und höher und bietet eine Vielzahl von Testfunktionen und Assertions. https://fortranwiki.org/fortran/show/FUnit    Fortran Unit Test (FUT): FUT ist ein weiteres Testframework für Fortran, das es ermöglicht, Unit-Tests für Fortran-Code zu schreiben. Es bietet Funktionen wie Assertions und die Möglichkeit, Testergebnisse zu protokollieren. https://github.com/dongli/fortran-unit-test   PFUnit (Parallel Fortran Unit Test): PFUnit ist ein Testframework, das speziell für den Test paralleler Fortran-Code entwickelt wurde. Es ermöglicht die Durchführung von Tests für parallele Funktionen und Routinen. https://github.com/Goddard-Fortran-Ecosystem/pFUnit Fortran Test Framework (FTF): Das Fortran Test Framework ist ein einfaches und leichtgewichtiges Testframework für Fortran. Es unterstützt die Erstellung von Unit-Tests und Assertions.   https://github.com/agforero/FTFramework Ein Flussdiagramm zur Beschreibung der Laufzeit:

    ForFUnit: ForFUnit ist ein weiteres Testframework für Fortran, das es ermöglicht, Unit-Tests für Fortran-Code zu schreiben. Es bietet Funktionen wie Assertions und die Möglichkeit, Testergebnisse zu protokollieren.       Fortuno Benutzerfreundliches, flexibles und erweiterbares objektorientiertes Fortran-Unit-Testing-Framework zum Testen von seriellen, MPI-parallelisierten und Coarray-parallelisierten Anwendungen. https://github.com/aradi/fortuno      

Aufbau von Testszenarien in Fortran

In Fortran gibt es keine eingebauten Testframeworks oder Assertions wie in einigen modernen Programmiersprachen. Daher müssen Entwickler Testroutinen und Assertions oft manuell implementieren. Hier ist ein einfaches Beispiel, wie ihr eine Testroutine mit Assertions in Fortran erstellen könnt: PROGRAM TestExample IMPLICIT NONE ! Function to be tested REAL FUNCTION Square(x) REAL, INTENT(IN) :: x Square = x * x END FUNCTION Square ! Test routine SUBROUTINE RunTests INTEGER :: numTests, i REAL :: input, result, expected ! Array of test cases: (input, expected result) REAL, DIMENSION(3, 2) :: testCases testCases = RESHAPE(, ) numTests = SIZE(testCases, 1) DO i = 1, numTests input = testCases(i, 1) expected = testCases(i, 2) result = Square(input) ! Assertion IF (result == expected) THEN WRITE(*, '(A, F6.2, A, F6.2)') 'Test ', input, ': Passed. Result = ', result ELSE WRITE(*, '(A, F6.2, A, F6.2, A, F6.2)') 'Test ', input, ': Failed. Expected = ', expected, ', Got = ', result END IF END DO END SUBROUTINE RunTests ! Run the tests CALL RunTests() END PROGRAM TestExample

Aufbau einer Testsuite in Fortran

In Fortran gibt es keine eingebaute Testsuit-Struktur wie in einigen modernen Programmiersprachen. Daher müssen Entwickler Testsuiten manuell implementieren. Eine Testsuite in Fortran ist eine Sammlung von mehreren Testroutinen, die verschiedene Funktionen oder Teile des Fortran-Codes testen. Hier ist ein einfaches Beispiel, wie Sie eine Testsuite in Fortran erstellen können: Angenommen, ihr habt eine Fortran-Datei my_functions.f90, die einige Funktionen enthält, die ihr testen möchtet. Ihr könnt eine separate Testdatei test_my_functions.f90 erstellen, die eure Testsuite enthält. ! Datei: my_functions.f90 MODULE MyFunctions IMPLICIT NONE CONTAINS ! Funktion 1: Berechne das Quadrat einer Zahl REAL FUNCTION Square(x) REAL, INTENT(IN) :: x Square = x * x END FUNCTION Square ! Funktion 2: Berechne die Fakultät einer ganzen Zahl INTEGER FUNCTION Factorial(n) INTEGER, INTENT(IN) :: n INTEGER :: i, result result = 1 DO i = 1, n result = result * i END DO Factorial = result END FUNCTION Factorial END MODULE MyFunctions   ! Datei: test_my_functions.f90 PROGRAM TestSuite USE MyFunctions IMPLICIT NONE ! Testroutine für Square SUBROUTINE TestSquare REAL :: input, result, expected ! Testfälle: (input, erwartetes Ergebnis) REAL, DIMENSION(3, 2) :: testCases testCases = RESHAPE(, ) WRITE(*, '(A)') 'Testing Square' DO i = 1, SIZE(testCases, 1) input = testCases(i, 1) expected = testCases(i, 2) result = Square(input) ! Assertion IF (result == expected) THEN WRITE(*, '(A, F6.2, A, F6.2)') 'Test ', input, ': Passed. Result = ', result ELSE WRITE(*, '(A, F6.2, A, F6.2, A, F6.2)') 'Test ', input, ': Failed. Expected = ', expected, ', Got = ', result END IF END DO END SUBROUTINE TestSquare ! Testroutine für Factorial SUBROUTINE TestFactorial INTEGER :: input, result, expected ! Testfälle: (input, erwartetes Ergebnis) INTEGER, DIMENSION(3, 2) :: testCases testCases = RESHAPE(, ) WRITE(*, '(A)') 'Testing Factorial' DO i = 1, SIZE(testCases, 1) input = testCases(i, 1) expected = testCases(i, 2) result = Factorial(input) ! Assertion IF (result == expected) THEN WRITE(*, '(A, I3, A, I6)') 'Test ', input, ': Passed. Result = ', result ELSE WRITE(*, '(A, I3, A, I6, A, I6)') 'Test ', input, ': Failed. Expected = ', expected, ', Got = ', result END IF END DO END SUBROUTINE TestFactorial ! Hauptprogramm der Testsuite CALL TestSquare() CALL TestFactorial() END PROGRAM TestSuite  

Wie man den Fehler hätte verhindern können?

Grundsätzlich gehe ich davom aus das die NASA solche Testmethoden einsetzt und auch entsprechende Emulationen laufen hat? Trotzdem wundert es das man hier eben doch falsche Befehle versendet hat. Entweder ist es menschliches Versagen, oder die Befehle wurden nicht ausreichend geprüft? Das Testen von falschen oder fehlerhaften Befehlen in Fortran kann schwierig sein, da der Fortran-Compiler normalerweise während der Kompilierung Fehler in ungültigen Befehlen erkennt und den Kompilationsprozess beendet. Dennoch könnt ihr in einigen Fällen Testfälle erstellen, um zu überprüfen, wie Ihr Code mit fehlerhaften Befehlen umgeht. Hier sind einige Möglichkeiten, wie ihr falsche Befehle in Fortran testen könntet: - Ungültige Variablennamen: Erstellt Testfälle mit ungültigen oder nicht deklarierten Variablennamen, um zu überprüfen, wie euer Code auf solche Fehler reagiert. - Syntaxfehler: Erstellt Testfälle mit fehlerhaften Syntaxkonstruktionen, wie beispielsweise fehlenden Klammern, falschen Zeichenketten oder fehlenden Semikolons. - Falsche Datentypen: Überprüft, wie euer Code auf ungültige Datentypen reagiert, z. B. wenn ihr versucht, eine Zeichenkette in eine ganze Zahl umzuwandeln oder umgekehrt. - Ungültige Compilerdirektiven: Testet, wie euer Code auf ungültige oder nicht unterstützte Compilerdirektiven reagiert. - Fehlerhafte Ein-/Ausgabeoperationen: Testet, wie euer Code auf fehlerhafte Ein-/Ausgabeoperationen reagiert, z. B. wenn ihr versucht, in eine geschlossene Datei zu schreiben oder von einer nicht vorhandenen Datei zu lesen. Die folgenden Beispiele zeigen, wie einige der oben genannten Szenarien in einer Testumgebung aussehen könnten: FUNCTION Divide(a, b) REAL, INTENT(IN) :: a, b REAL :: Divide IF (b == 0.0) THEN WRITE(*, '(A)') 'Error: Division by zero.' STOP END IF Divide = a / b END FUNCTION Divide SUBROUTINE TestNegativeDivision REAL :: result ! Negative Test: Division durch Null result = Divide(5.0, 0.0) ! Erwartung: Fehlermeldung "Error: Division by zero." END SUBROUTINE TestNegativeDivision FUNCTION GetStringLength(str) CHARACTER(*), INTENT(IN) :: str INTEGER :: GetStringLength GetStringLength = LEN_TRIM(str) END FUNCTION GetStringLength SUBROUTINE TestInvalidStringLength INTEGER :: length CHARACTER(5) :: myString = "Hello" ! Negative Test: Zuweisen eines zu langen Strings zu einer begrenzten Zeichenkette length = GetStringLength(myString) ! Erwartung: Compilerfehler oder Laufzeitfehler END SUBROUTINE TestInvalidStringLength Diese Beispiele zeigen, wie ihr Testfälle erstellen könnt, die fehlerhafte Befehle in eurem Fortran-Code auslösen, um sicherzustellen, dass euer Code angemessen auf solche Fehler reagiert. Wie in jeder anderen Sprache sollte man auch die entsprecchenden Workflows einhalten. Es geht immer um den Test von Schwachstellen, daher ergeben sich auch immer die gleichen Szenarieren im Test. Statische Code-Analyse: Statische Code-Analysetools durchsuchen euren Quellcode, um mögliche Schwachstellen und Fehler zu erkennen, ohne den Code tatsächlich auszuführen. Diese Tools können beispielsweise potenzielle Speicherzugriffsfehler, uninitialisierte Variablen oder unsichere Aufrufe von Funktionen erkennen. Einige gängige statische Analysetools für Fortran sind: - Frama-C: Ein Framework für die statische Analyse von C- und Fortran-Code. - FortranLint: Ein kommerzielles statisches Analysetool für Fortran. Dynamische Code-Analyse: Dynamische Code-Analysetools führen Ihren Code aus und überwachen sein Verhalten zur Laufzeit. Diese Tools können Laufzeitfehler, Speicherlecks und andere potenzielle Probleme erkennen. Beim Testen von Fortran ist es wichtig, Ihre Tests mit verschiedenen Eingabewerten und Grenzfallbedingungen durchzuführen. Mit selbst ist nur ein Tool bekannt welches Entsprechend ab Fortran 77 eingesetzt werden kann: Code-Reviews: Peer-Reviews und Sicherheitsüberprüfungen sind ebenfalls wichtige Schritte, um potenzielle Schwachstellen im Code zu entdecken. Lassen Sie andere Entwickler Ihren Code überprüfen und Feedback geben, um mögliche Sicherheitslücken zu identifizieren.

Kann man diesen Testcode automatisieren?

Ja, ihr könnt den Testcode in Jenkins oder GitHub in einer Pipeline automatisieren, um eine kontinuierliche Integration und automatisierte Testabläufe zu ermöglichen. Beide Plattformen bieten Möglichkeiten, Skripte und Tests in einer Pipeline zu definieren und auszuführen, um sicherzustellen, dass euer Code kontinuierlich getestet wird. Es wundert mich das dieser fehler gerade der NASA passiert ist, denn einige der oben genannten Testframeworks sind eigene Entwicklungen von NASA Mitarbeitern. Beispiel Jenkins: In Jenkins könnt ihr eine Pipeline erstellen, um eure Fortran-Tests zu automatisieren. Ein einfacher Jenkins-Pipeline-Code könnte wie folgt aussehen: pipeline { agent any stages { stage('Build') { steps { // Hier den Code aus dem Repository klonen und den Fortran-Compiler ausführen, um den Code zu kompilieren } } stage('Test') { steps { sh 'gfortran -o test_my_functions test_my_functions.f90 my_functions.f90' // Kompilieren des Testcodes sh './test_my_functions' // Ausführen der Testsuite } } } } Beispiel Github Actions; In GitHub können Sie eine ähnliche Pipeline in Form von GitHub Actions erstellen. GitHub Actions ermöglicht es Ihnen, den Testcode in einer YAML-Datei zu definieren, die im Repository gespeichert wird. Read the full article

[gunken]

Retro Schnipsel auf YouTube

Retro Schnipsel auf YouTube

Youtube Kanal Retro Schnipsel ist seit gestern online … Aber Wieso? Naja ich halte das wie diesen Blog. In erster Linie sammle ich hier Infos, um mich später wieder daran zu erinnern, wie ich es gemacht habe 😉 Die Themen drehen sich um C64 Basic Programmierung, Erweiterungen und natürlich JiffyDOs. Bei den Schnipseln möchte ich aber folgendes Format einhalten. Es ist immer ein One-Take Ich…

[feuershow]

Project Fire® Feuershow Leipzig Dresden Chemnitz - VIDEO Jahresrückblick 2019

Project Fire® Jahresrückblick 2019 // NEUES VIDEO ist ONlinE!!!

So da wäre das Jahr schon wieder fast rum. Und wenn man sich 2019 so anschaut, dann hat man wieder viele coole Feuerlichtshows oder LED-Shows gezaubert. Feuershow plus Lichtshow und weitere Effekttechnik macht es möglich. Es wurde wieder entwickelt und entwickelt und viele Dinge für 2020 stecken bereits in der Schublade. Das Jahr 2019 wurde wieder in ein schickes Abschlussvideo gepackt. Aufnahmeorte diesmal: // Staupitzbad Döbeln // Schloss Albrechtsberg // Carte Blanche Dresden // Berzdorfer See Görlitz // Augustusberg Bad Gottleuba // Wasserschloss Klaffenbach // Landgasthof Rittersgrün // Fittico Chemnitz // Villa Theresa Coswig // Haus des Gastes Reichenbrand // Gasthof Tauscha Deswegen war 2019 auch wieder ein Jahr , wo man viele Shows extrem unterschiedlich aufgebaut hat. Aufgrund der Vielzahl der Lichttechnik sieht jede Show alleine schon vom Aufbau her anders aus. Individuell und exklusiv direkt für jede Veranstaltung. Die Feuershow in Klaffenbach vor dem Wasserschloss oder in Görlitz am Berzdorfer See waren zirka 30 Meter breit. Wenn man solche Flächen zur Verfügung hat, dann macht es natürlich immer wieder Spaß, die volle Breite zu nutzen. Aber die Zusammenstellungen der Shows sind ja immer nur ein Teil des Ganzen. 2019 wurde eine neue Show ins Leben gerufen welche die bisherige Show um das zehnfache an Datenströmen liefert. Wozu der Aufwand ? Einfach für die Gänsehaut welche dadurch erzeugt wird und weil es einfach Spaß macht immer mehr Zahlen ineinander zu programmieren. Es macht dann Spaß die Show anzuschauen auch wenn noch gar keiner auf der Bühne steht. Diese Mischung der Programmierung zusammen mit der neu gestalteten Musik und letztendlich der Akteur selbst, harmonieren perfekt zusammen. Und dabei wird enorm viel Zeit hineingesteckt. Gerade musikalisch hat es wieder knapp 1 Jahr gedauert. Aber Musik ist auch das A und O der Show. Und ich denke das es dieses Mal wieder perfekt gelungen ist. Natürlich gibt es das Ganze dann nur live zu erleben. Am 15.11 und 16.11. läuft die neue Feuerlichtshow sowie die neue Indoor LED Show noch einmal über die Bühne. Am 15.11 in Neugersdorf zum Feuerzauber 2019. Da wir dort 2 Shows abliefern haben wir uns was Spezielles einfallen lassen. Einmal voll Retro 2012 umprogrammiert auf die neue Technik und als 2. Show die neueste Kreation aus dem Hause Project Fire. Uuuunnnd am 16.11.2019. als Special Act zum Fasching in Chemnitz Reichenbrand. Es ist alles vorbereitet und es ist alles programmiert. Und das schönste ist... 2020 geht es wie immer weiter :) Ob in Chemnitz Leipzig oder Dresden. Project Fire bietet Shows für Ihre Anlässe wie Firmenveranstaltungen / Hochzeiten / Stadtfeste/ Indoor Shows / Galas / Geburtstage / Jugendweihen und und und. Nach wie vor auch spezielle Kombinationen aus Tanz und Feuer machen wir von Project Fire gerne mit. Feuerjonglage oder Lichtjonglage mit Feuerstäben, Grafikstäben, Feuerpoi, LED-Poi und vielen neuen Entwicklungen präsentieren wir Ihnen auch 2020 wieder. In dem Sinne viel Spaß mit dem Video.   Read the full article

[netcommunic-blog]

... ich baue mir einen Bot, - meinen persönlichen Assistenten :) 

Wisst Ihr noch. Einmal klatschen, Licht an. Zwei Mal Klatschen Licht aus.

Über kurz oder bald, mindestens zu Weihnachten, - führt kein Weg mehr daran vorbei. Smart-Home, dem IoT (Internet der Dinge) wird Einzug halten, dem wird man sich kaum mehr entziehen können, oder wollen.

Es ist an der Zeit sich damit intensiver, in der Praxis auseinanderzusetzen!

Meine ersten Erfahrungen mit einem Chatbot habe ich vor 10 Jahren mit ELIZA gesammelt. Letztes Jahr im Februar hatte ich mich dazu, länger mit Rose, aus San Francisco, unterhalten. Eine wahre Expertin. http://ralf-larisch.blogspot.de/2016/02/ein-gedankenaustausch-der-besonderen-art.html und seit gut einem Jahr beschäftige ich mich regelmäßig mit meinem Raspberry-Retro - Radio, meinem Telefunken-Radio gavotte 201, Baujahr zwischen: 1969-1972 http://bit.ly/2g3sgR7 , das inzwischen online gehen kann.   Keine Hardware ohne Software. Um meinen persönlichen Assistenten Leben einzuhauchen, nennt mich Dr. Frankenstein ;) braucht's ein Entwicklertool.Human-Computer-Interaktionstechnologien

Ich habe mich im ersten Schritt für API.AI (http://bit.ly/2xO9zsm) entschieden, es gehört seit 2016 zu Google (Alphabet) und ist quasi ein #SCRATCH für Erwachsene. 

Was? So kompliziert ist dass alles? Keiner möchte einen Kaffeevollautomaten programmieren um sich Kaffee zu zapfen. Is das alles wirklich so komplex? Nein! Im Gegenteil: Die Technologien werden immer einfacher zu integrieren sein. Viel zu einfach. Keiner muss mehr nachdenken, nicht einmal mehr verstehen. Keine unverständlichen Anleitungen, wie zu Zeiten der Programmierung eines Videorecorders. Ebenso verhält es sich bei Assistenzsystemen, wie Google-Home, Amazons Alexa, oder Apple's Siri. Jedoch, kann es durchaus spannend sein, die Technologie, den Algorithmus dahinter verstehen zu lernen, um sich in Zukunft mit diesen Alltagstechnologien souverän auseinanderzusetzen. 

Das ist auch Bestandteil meiner ThinkD!gital, dem Lern-Dienstleistungszweig meiner Beratungstätigkeit, als Consultant für digitale Strategien.

Und mein Geheimnis, das ich hiermit offen lege, ist: Ich habe keinerlei Kompetenzen im Programmieren, leider :( es verhält sich eher, wie mein Gesang in der Badewanne. Freude daran, ab und zu einige Töne zu finden, die harmonieren. 

Shoshin (初心) , der ewige Beginner-Geist

Im April, diesen Jahres habe ich begonnen, mich ein wenig mit SCRATCH zu befassen, einem Basis-Programm, zum Programmieren, für Kinder und Erwachsene wie mich :) http://ralf-larisch.blogspot.de/2017/01/das-kannst-du-auch.html In meiner Jugend bereits hatte ich mich mit Basic befasst. Locomotive BASIC, einem Interpret aus der Schneider/Amstrad CPC-8bit-Homecomputerbaureihe. Zwischen den Zeiten lag praktisch nichts, außer einige Scripts zum Bewältigen administrativer Aufgaben. Ich bin also nicht mehr, als ein Hausmann, der in der Lage ist, einen tropfenden Wasserhahn zu reparieren. 

Großartige Voraussetzungen um jede Menge Spaß zu haben :)

Gestern nun habe ich den Anfang gemacht und mein ganz persönliches Projekt "Google Home" gestartet und ein erstes "Hallo Welt" Erfolg, kann ich bereits verbuchen, so hört mein Bot bereits auf eine meiner Fragen und reagiert freundlichst ergeben ... Danke Google.

Verbünde Dich. Google hat das Internet geprägt, wie kaum ein anderes Unternehmen. Warum also nicht, Google als Basis zum Erlernen digitaler Strategien nutzen? Mit Google lernen, wie unsere digitale Welt so tickt.

https://sites.google.com/view/netcommunic/google-lernen

Das Equipment für meine ThinkD!gital, digitale Kompetenzentwicklung in der Erwachsenenbildung, finanziert sich derzeit noch aus meiner eigenen Tasche.

Ich freue mich über jede unverbindliche Zugabe von Mitteln, Ideen und Kooperationen. Wer möchte, kann mein Projekt finanziell unterstützen. Bspw. über Amazon-Gutscheine

Das Budget für den Bot liegt bei ca. 300 Euro.Geplant ist, die Anschaffung eines Google-Home und das äquivalent Amazon's Alexa. 2 Dot Einheiten.

Hier geht es zu meiner Fundraising Seite: https://www.leetchi.com/c/thinkdigital

Hier geht es zu Amazon-Gutscheine: http://amzn.to/2xUexWI

Hier geht es zu meiner Suche nach Corporates "Softwareentwickler" https://goo.gl/forms/1O0Xtpkl1cfkLG8L2

Ich freue mich über Kommentare, das Teilen und Weitersagen. Mitmachen und alle, die mich inspirieren und begleiten wollen.

Vielen Dank für Eure Unterstützung und Eure Zeit.

Beste Grüße aus München Ralf

[basic-retro-programming]

QBasic Tutorial #48 - Bouncing Ball Animation ...

Post #304: YouTube, School Freeware, QBasic Tutorial, #48 Bouncing Ball Animation in QB64, 2024.

[basic-retro-programming]

Post #311 : Der Standard, Jacob Sapotozky, Life Skills, Drei Dinge, die ich in einem Jahr Programmieren gelernt habe, 2024.

[basic-retro-programming]

QBasic Tutorial #39 - Text Files Part 1 - Making A Text File - Reading A Text File ...

Post #268: YouTube, SchoolFreeware, QBasic Tutorial, #39 Making A Text File, Part 1, 2023.

[basic-retro-programming]

Die Programmiersprache QuickBasic ...

Post #239: Wikipedia, Microsoft QuickBasic, Geschichte, Funktionalitäten, Kompatibilität, QuickBasic heute, 2023.

[basic-retro-programming]

GW-BASIC against the world

Ok, I'll admit up front: GW-BASIC is far from the best language with which to write modern software. GW-BASIC is a non-structured programming language in the purest sense of the term: as long as you confirm to appropriate syntax, and line number everything properly, you can pretty much code a program any way you please. No procedures to follow. No classes, no structures, no functions, and no objects to worry about. And all of the many other things that go along with object-oriented programming (OOP), like polymorphism, inheritance, superclasses, and subclasses, are well beyond the scope of even the most complex GW-BASIC programming toolkit. Which is GW-BASIC's great strength – and, most people would argue, if they've even seen the language in action, its greatest weakness.

But it doesn't matter. In my first book about GW-BASIC, Not Ok, I argued that a full-flowering of creative algorithmic expresseion isn't dependent upon a grab bag of available complex syntactical structures, but rather on how those keywords and routines that actually are accessible by the programmer are creatively arranged. Essentially, it's not what you have but how you use it – and GW-BASIC, in not having that complex array of modern-day programming apparatus, in effect forces the coder to conserve, optimize, and even occasionally resort, to sleight of hand. When it comes to coding in GW-BASIC, I'm less interested in 'propper' programming etiquette (such as it is) and more concerned with ways to producing the program outcomes desired.

GW-BASIC gegen die Welt

Ok, ich gebe es gleich zu: GW-BASIC ist bei weitem nicht die beste Sprache, um moderne Software zu schreiben. GW-BASIC ist eine unstrukturierte Programmiersprache im reinsten Sinne des Wortes: Solange man sich an die richtige Syntax hält und alles richtig nummeriert, kann man ein Programm so ziemlich nach Belieben codieren. Keine Verfahren sind zu befolgen. Keine Klassen, keine Strukturen, keine Funktionen und keine Objekte, um die man sich Sorgen machen müsste. Und all die vielen anderen Dinge, die mit der objektorientierten Programmierung (OOP) einhergehen, wie Polymorphismus, Vererbung, Oberklassen und Unterklassen, gehen weit über den Rahmen selbst des komplexesten GW-BASIC-Programms hinaus. Das ist die große Stärke von GW-BASIC - und die meisten Leute würden argumentieren, wenn sie die Sprache überhaupt in Aktion gesehen haben, ihre größte Schwäche.

Aber es spielt keine Rolle. In meinem ersten Buch über GW-BASIC, Not Ok, habe ich argumentiert, dass ein guter Algorithmus nicht abhängig ist von der Komplexität syntaktischer Strukturen, sondern vielmehr davon, wie die Schlüsselwörter und zur Verfügung stehenden Routinen tatsächlich genutzt werden und der Programmierer sie kreativ arrangiert. Im Wesentlichen kommt es nicht darauf an, was Sie haben, sondern wie Sie es verwenden - und da GW-BASIC nicht über diese komplexe Anordnung moderner Programmiersprachen verfügt, zwingt es den Programmierer tatsächlich, zu sparen, zu optimieren und gelegentlich sogar auf Taschenspielertricks zurückzugreifen. Wenn es um das Programmieren in GW-BASIC geht, interessiere ich mich weniger für die „richtige“ Programmieretikette (so wie sie ist) als vielmehr für die Möglichkeiten, die gewünschten Programmergebnisse zu erzielen.

Mein Kommentar zu diesem Zitat: Mit den meisten Gedanken von Mark Jones Lorenzo bin ich einverstanden. GW-BASIC aber als eine komplett unstrukturierte Programmiersprache zu bezeichnen, finde ich etwas übertrieben. Man kann auch mit GW-BASIC recht strukturiert programmieren. Hierzu gehört aber eine gewisse Selbstdisziplin beim Programmieren: 1. mit eigenen Routinen (GoSubs), um Redundanz zu vermeiden, 2. nachvollziehbare und gut kommentierte Quelltexte, 3. übersichtlicher Gebrauch von Variablen und 4. mathematische Funktionen, die zur Verfügung gestellt und selbst erstellt werden können. Wenn man 5. den GoTo-Befehl nur dann benutzt, wenn er unbedingt nötig ist, kann auch ein GW-BASIC-Programm recht überschaubar und gut nachvollziehbar sein, ohne den berüchtigten Spaghetti-Code mit Tomatensoße zu erzeugen. :)

My comment on this quote: I agree with most of Mark Jones Lorenzo's thoughts. But to call GW-BASIC a completely unstructured programming language is a bit of an exaggeration. You can also program in a very structured way with GW-BASIC. However, this requires a certain self-discipline when programming : 1. with your own routines (GoSubs) to avoid redundancy, 2. understandable and well-commented source code, 3. clear use of variables and 4. mathematical Functions that are built-in resp. available and self-created. 5. If you only use the GoTo command when it is absolutely necessary, even a GW-BASIC-Program can be quite manageable and easy to understand without generating the notorious spaghetti code with tomato sauce. :)

Post #103: Mark Jones Lorenzo, The Resurrection of GW-BASIC, Introduction: GW-BASIC against the World, SE Books, Philadelphia, S. 15, 2017.

[basic-retro-programming]

Retro-Programmierung mit GW-BASIC 3.23 ...

Der Quelltext des Programms ...

Das eingegebene Programm im Interpreter und die Ausgabe am Monitor ...

Post #090: Retro-Programmierung mit GW-BASIC 3.23, Roland Schneidt, So macht Informatik Spaß, Band 1, Programm 6, Tanken, Ludwig Schulbuch Verlag, Pfaffenhofen, 1991.

[basic-retro-programming]

Buchtipp für Retrofans #24 ...

Said Baloui war in den 1990er Jahren eine der wenigen Autoren, die mir einen Zugang in die Welt der Programmierung verschafft haben. Es hat mir damals sehr viel Spaß gemacht, seine Bücher über GW-BASIC, QBasic und QuickBasic zu lesen. Ich besitze sie heute noch in meinem privaten EDV-Antiquariat.

Post #160: Buchtipp für Retrofans #24, Said Baloui, QBasic Einführung, Das Grundwissen zur PC-Programmierung in QBasic, Markt & Technik Verlag, Haar bei München, 310 Seiten, 1993.

[basic-retro-programming]

SchoolFreeware, QBasic Tutorial 6/64, User Input ...

The source code and output of tutorial 6/64 ...

Post #130: SchoolFreeware, QBasic Tutorial, 6/64, User Input, 2023.