{"id":836,"date":"2023-08-30T07:30:06","date_gmt":"2023-08-30T07:30:06","guid":{"rendered":"https:\/\/research.swissdigitization.ch\/?p=836"},"modified":"2023-08-30T07:30:06","modified_gmt":"2023-08-30T07:30:06","slug":"assembler-inklusive-basic-tutor-vs-moderne-strukturierte-programmiersprachen-c-pascal-c-pascal-brainfuck-in-bearbeitung","status":"publish","type":"post","link":"https:\/\/research.swissdigitization.ch\/?p=836","title":{"rendered":"Assembler (inklusive Basic, Tutor?) vs moderne strukturierte Programmiersprachen (C, Pascal, C++, Pascal, Brainfuck) [In Bearbeitung]"},"content":{"rendered":"\n
\"\"<\/figure>\n\n\n\n

Wer Assembler programmiert (oder auch Basic mit Goto Zeilennummern\/Sprungmarkenm\u00f6glichkeiten) stellt schnell fest, hier kann man viel mehr machen als in modernen strukturierten Programmiersprachen (mit derselben Anzahl von Zeichen). Moderne strukturierte Programmiersprachen \u00e4hneln mehr einem modernen Rezept, w\u00e4hrend unstrukturierte eher einem Hypertext \u00e4hneln. <\/p>\n\n\n\n

Moderne strukturierte Programmiersprachen und ihr Baumkonzept<\/strong><\/p>\n\n\n\n

Moderne (strukturierte) Programmiersprachen und ihre Ablaufdiagramme sind eine Teilemenge (nicht eigentlich) der viel gr\u00f6sseren Menge der Maschinensprachen mit ihren JMP und GOTO Befehlen. Der Code springt in Unterroutinen und kehrt dann wieder zur\u00fcck in den n\u00e4chst h\u00f6heren Prozess.<\/p>\n\n\n\n

Dadurch entsteht eine Art Baum und wie bei Treestrukturen \u00fcblich, ist es jederzeit klar, wo sich der Programmpointer(‚man‘) befindet. Jeder Punkt ist klar definiert, weil der R\u00fcckweg immer klar ist – den Tree up. Je tiefer der Tree ist, umso gr\u00f6sser die Verwaltungsaufgabe, schliesslich muss man sich immer merken, wie man zur\u00fcckkommt. <\/p>\n\n\n\n

Prinzipiell hat C. B\u00f6hm ( https:\/\/en.wikipedia.org\/wiki\/Corrado_B\u00f6hm<\/a> ) fr\u00fch – 1963 – gezeigt, dass sich alle unstrukturierten Programmiersprachen in strukturierte \u00fcberf\u00fchren lassen. Er hat dazu eine theoretische Programmiersprache entwickelt mit sehr wenigen Befehlen. Eine wiedererfundene Version daf\u00fcr kennt man heute Brainfuck von U. M\u00fcller<\/a>, das nur von den Befehlen +-[] etc lebt. Diese Sprache hat nat\u00fcrlich einen Preis, die Source-Codes sind riesig.<\/p>\n\n\n\n

Der Vorteil ist sofort klar: Lesbarere Strukturen (Trennung zwischen Fakten und Regeln klar), da es klare Ablaufdiagramme gibt. <\/p>\n\n\n\n

An verschiedenen Stellen (raussuchen) wird darauf hingewiesen, dass gerade 8Bitter wegen RAM (auch in Sachen Tools) und kleinem Stack nicht in der Lage sind wirklich h\u00f6here strukturierte Programmiersprachen zu bieten. Es f\u00e4llt auch auf, dass es wenige strukturierte Programmiersprachen gibt auf diesen Systemen und viele erst heute nachtr\u00e4glich entwickelt werden, um zu zeigen, dass es doch funktioniert. <\/p>\n\n\n\n


\/\/ ToDo: Checken der These, dass es bei 8Bit-Homcomputern wenige Compiler und Hochsprachen gibt, weil das RAM fehlte bzw. die Stacks zu klein waren f\u00fcr gute Compiler.<\/p>\n\n\n\n

\/\/ Trees sind deswegen bekanntlich sehr beliebt, da sie machttechnisch gr\u00f6sstm\u00f6gliche Kontrolle erlauben. Nat\u00fcrlich lassen sich damit nur eine beschr\u00e4nkte Datenstruktur oder auch Prozessstruktur abbilden – aber f\u00fcr viele Systeme reicht es (oder eher muss es reichen).<\/p>\n\n\n\n

Unstrukturierte Programmiersprachen – willkommen in rhizomatischer Ausf\u00fchrung<\/strong><\/p>\n\n\n\n

Assembler dagegen ist das potentiell offen in der Struktur. Es kann kreuz und quer Daten uns Code verteilt werden (nicht der beste Stil) – letztlich besteht darin auch kein Unterschied – das eine sind ausf\u00fchrbare Daten, das andere interpretierte Daten – aus Sicht des Programs. <\/p>\n\n\n\n

Prinzipiell gibt es wenige Befehle. LDA (load A), STA (store A), CMP, JMP. Dadurch entstehen logisch stringente Programme. Ebenso ist das Rechenwerk meist sehr eingeschr\u00e4nkt (etwa beim billigen 6502): Register A,X,Y. All dies macht die Programm lang und oft schwer lesbar. <\/p>\n\n\n\n

Als Flaschenhals kommt hinzu, dass viele Operationen nicht im allgemeinen (langsamen) RAM ausgef\u00fchrt werden k\u00f6nnen, sondern nur im ‚Rechenwerk‘ und darum dahinein geladen werden m\u00fcssen bsp. lda #1 (Lade 1 ins A-Register). <\/p>\n\n\n\n

Der wichtigste Unterschied zu strukturierten Programmiersprache ist aber sicherlich die M\u00f6glichkeit des „Springens“ JMP (oder GOTO) und alle Flag-Abh\u00e4ngigen-Spr\u00fcnge aus „Compares wie CMP“ wie BEQ (gleich), BNE (ungleich), BCC (kleiner als), BCS (gr\u00f6sser als) etc. <\/p>\n\n\n\n

Ein fiktives Beispiel:<\/p>\n\n\n\n

        lda #10\nohje:\n        clc\n        adc #1\n\n        clc \/\/ clean the state-register\n        cmp #4\n        beq it_is_four \/\/ same\n        bne it_is_notfour \/\/ not the same \n\nit_is_four:\n\n        jmp end_of_all\nit_is_notfour:\n\n        jmp oh_je\nend_of_all:       <\/code><\/pre>\n\n\n\n
Dies erm\u00f6glicht dann alle m\u00f6glichen Versionen von Ausf\u00fchrungen. Komplizierter wird das Ganze dann auch noch, wenn sich der Source-Code \u00fcber mehrere Seiten erstreckt. Und selbstverst\u00e4ndlich lassen sich Dinge in Unterroutinen verpacken, das Problem allerdings dann da: Handling der Parameter (auf den kleinen Stack oder in eigene Variablen?). <\/p>\n\n\n\n
Im konkreten Programmierprozess m\u00fcssen durch die Sprungmarken auch immer wieder neue Sprungmarken gefunden werden. Dies ist bei weitem aufw\u00e4ndiger als etwa in C. Die Haupbenennungsaufgaben sind quantitativ die Variablen\/Members und die Methoden. 

Die Variablen sind \u00e4hnlich aufw\u00e4ndig in Assembler:<\/p>\n\n\n\n
a: .byte 0 
vs 
byte a = 0;<\/code><\/pre>\n\n\n\n
 Dasselbe gilt f\u00fcr die Funktionen\/Methoden:<\/p>\n\n\n\n
render_me:\n           [...]\n           rts\n\nvs\n\nvoid render_me() {\n}<\/code><\/pre>\n\n\n\n
Viel aufw\u00e4ndiger wird es hingegen bei jeder kleine If-Abfrage bzw. in Sachen fornext (was ja eine verk\u00fcrzte Schreibweise ist C). Hier m\u00fcssen immer wieder neue Sprungmarkennamen gefunden werden (auch wenn moderne Assembler hier auch lokale relative Namings erm\u00f6glichen).<\/p>\n\n\n\n
            ldx #10\ncount_down:\n            clc\n            cpx #4\n            is_not4\n      \nis_not4:             \n            inx\n            clc \n            cmp #0\n            bne count_down\n\nvs\n\nfor (int i=0;i<10;i++) {\n    if (i==4) {\n    \n    }\n}<\/code><\/pre>\n\n\n\n
Selbstverst\u00e4ndlich klingt, das im ersten Moment nicht nach viel. Das Problem potentiert sich aber dann mit jeder neuen Abfrage und jeder ForNext-Schleife.

<\/p>\n","protected":false},"excerpt":{"rendered":"
Wer Assembler programmiert (oder auch Basic mit Goto Zeilennummern\/Sprungmarkenm\u00f6glichkeiten) stellt schnell fest, hier kann man viel mehr machen als in modernen strukturierten Programmiersprachen (mit derselben Anzahl von Zeichen). Moderne strukturierte Programmiersprachen \u00e4hneln mehr einem modernen Rezept, w\u00e4hrend unstrukturierte eher einem Hypertext \u00e4hneln. Moderne strukturierte Programmiersprachen und ihr Baumkonzept Moderne (strukturierte) Programmiersprachen und ihre Ablaufdiagramme sind […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[39,38,36,15,37,1],"tags":[],"class_list":["post-836","post","type-post","status-publish","format-standard","hentry","category-16bit","category-8bit","category-assembler","category-coding","category-strukturierte-programmiersprachen","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/posts\/836","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=836"}],"version-history":[{"count":7,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/posts\/836\/revisions"}],"predecessor-version":[{"id":844,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=\/wp\/v2\/posts\/836\/revisions\/844"}],"wp:attachment":[{"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=836"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=836"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/research.swissdigitization.ch\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=836"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}