Maschinensprache/Assembler - wo gingen eure Erfahrungen los, warum, welche und was sagt ihr retrospektiv dazu?

S

ssssssssssss14316

Guest
Angeregt durch den BASIC Thread, einer Interpretersprache, bei der ich mich schon auf dem C64 nicht heimisch gefühlt habe, weil mit alles viel zu simpel, starr und eingeschränkt vorkam, habe ich relativ schnell meine Programmierfühler nach anderen Dingen ausgestreckt und habe die für mich damals wichtigsten Programmiersprachen entdeckt (wichtig einfach, weil sie mich über viele Jahre begleiten sollten): zum einen K&R C und zum anderen Assembler, bei dem ich hauptsächlich auf dem Motorola 68000er und den späteren Varianten die meisten Erfahrungen gesammelt habe. Der Hintergrund war rein praktischer Natur. Zu dieser Zeit war es en vogue als Jugendlicher in der Demoszene zu sein, Intros und Demos zu programmieren (UND die entsprechenden Soundstücke zu schreiben) [Zumindest dachten das alle Nerds :) ]. Und das ging nun mal in Assembler damals noch am effektivsten, da man noch bedacht sein musste, was man tat, wollte man nicht zu viel Prozessortakte vergeuden und nur langweilige Demos mit unaufregenden Effekten hinzaubern. Außerdem war es der spaßigste Weg, die Interna eines Computers kennen zu lernen. Ich kann mich noch an zahllose Stunden (eigentlich waren es zumeist Nächte) des Programmierens von Agnus, Paula und Denise erinnern und blicke mit wohliger Wärme auf jene Zeit des Aufbruchs zurück (Warum nur Habe ich die Hardware verkauft, ich Idiot! Ach ja, mangelnder Platz, und weil ich nie ein Messi werden wollte.). Aber nicht nur deswegen fand ich die Erfahrungen sehr gut, es war für mich so eine Art des besseren Wegs, die Interna der Computer kennen zu lernen, so ganz ohne Internet (das für Privatleute noch nicht mal in den Kinderschuhen steckte), aber dafür mit beinbrechenden Schmökern, wie dem Amiga Rom Kernel Reference Manual (zugegebenermaßen weniger bei Demos) und anderen Baumtötern aus Papier.

Mich würde mal interessieren, was ihr so damals in welchem Assembler, auf welchem(n) Gerät(en) gemacht habt, und wie ihr das im Nachhinein beurteilen würdet. Wie steht ihr zu Assembler heute? Es ist klar, dass die Prozessoren heutzutage wesentlich komplexer sind und Programmierung in Assembler nur selten gerechtfertigt wäre, aber gibt es Fälle, wo ihr es dennoch tut und warum? Auf welchen Prozessoren? Wie beurteilt ihr die unterschiedlichen Assembler der unterschiedlichen Prozessorarchitekturen? Benutzt ihr manchmal Inline-Assembler? Und alles, was euch sonst noch so zu diesem Thema einfällt ...
 
Bei mir war es "damals" c64 Assembler, später 68000 (Amiga), dann x86. Auf dem c64 habe ich noch nichts auf die Kette bekommen (kam direkt von basic und hatte mich immer gefragt, was soll ich denn mit den minimalistischen Befehlen anfangen). Auf dem Amiga hatte ich dann immerhin schon mal damit angefangen mein eigenes Click and Point Adventure zu programmieren. So mit Grafik und Sound. Ist natürlich nie fertig geworden. Immerhin gab es eine erste Szene wo man eine Tür öffnen konnte. einen selbstgemachten Soundtrack gabs auch. x86 Assembler war dann Teil meiner Ausbildung. Habe seitdem aber nie wieder in Assembler programmiert, Ich korrigiere mich: nie wieder ein Programm komplett in Assembler geschrieben. Ist heutzutage etwas zu umständlich. Aber es ist sehr hilfreich, dass man es kann, weil man in C und C++ eben auch kleine Teile in Assembler schreiben kann, wenn es drauf ankommt. Außerdem kann man mit einem Dissasembler anschauen, was der Compiler aus dem Quelltext gemacht hat und dann Details nachbessern.
Insgesamt finde ich es durchaus hilfreich, wenn man weiß, was der Prozessor genau tut, ermöglicht einem auch in anderen Sprachen von dem gewonnenen Wissen zu profitieren. Der "Nachwuchs" hat heutzutage kaum noch eine Ahnung was ein Interrupt eigentlich ist.
 
dbra schrieb:
Jaja, die Jugend wieder. Hat mal wieder keinen Plan, wie's richtig muss.
Zum Vergrößern anklicken....
Das ist eine mögliche Interpretation. Die Ansicht wie es richtig muss ändert sich mit der Zeit. Ich bin da mittlerweile sehr vorsichtig, wenn es darum geht "wie es richtig" ist. Dennoch gibt es aus der konservativen Perspektive durchaus einen Verlust in Bezug auf Fertigkeiten die man früher gelernt hat und heute halt nicht mehr...
 
ZX Spectrum als Nachbau (nicht von mir selbst gebaut, ich selber habe das Netzteil dazu gebaut/gelötet/layoutet) war mein erster eigener Computer. Zunächst mit Basic programmiert. Dann etwas mit Assembler. Aber nicht viel. Dann habe ich einen 286er bekommen, und ab da habe ich mich mit Assembler nicht weiter beschäftigt, sondern in höheren Sprachen etwas programmiert. Sogar noch einige Anwendungen für technisches Studium. Mich hat aber zunehmend musikalische Anwendung interessiert, und als ich einen Zugang zu fertiger Musik-Software und zu Hardware-Klangerzeugung bekommen habe, habe ich selber nicht mehr weiter programmiert. Später dann im weiteren Studium etwas HTML, PHP, SQL. Aktuell schraube ich lieber an Sounds, Effekten, Sequencer von fertigen Produkten. Klar würde es mich auch reizen etwas mitzuentwickeln, aber das wäre für mich eigentlich trotzdem Mittel zum Zweck. Der Zweck war und ist Erstellung von Musik, seitdem ich diese Möglichkeiten entdeckt habe.
 
Bei mir erstmal mit 1-Platinen Rechner (weiss nicht mehr den Hersteller, da musste ich hin gehen, das war nicht meiner) - also alles zu Fuß. Das war dann auch eine Erfahrung - fast wie einen MC8 zu programmieren.
Danach dann mit Z80A in Sinclair Maschinen und später gab es dafür passende Assembler Tools, was es massiv vereinfacht hat - fand aber zu Fuß weiter gut - also nicht immer einen Editor genutzt - irgendwann weiss man wie die Zahlen zu was gehören, Sinclair ist ja eh was mit eine Taste ein Befehl und das ist ein Byte. Z80A ist ein Ding was auch unterschiedliche Register hat aber es war DER Prozessor damals. Inkl MSX - dasselbe. ich hab kein 6502 gemacht, das war das Commodore-Ding, aber hatte Berührung mit einer Reihe anderer Rechner, aber meist eben nicht mit Assembler.

Danach Atari 68k - das war schon wieder anders, aber da direkt mit einem Assemblertool, da konntest du ld,A oder sowas tippen.
Und mit dem Mac muss ich zugeben, habe ich kein PPC Assembler mehr geschrieben - da war es dann eher C++ und Java und sowas, keine Maschinensprache mehr.
Ich mag den Namen Maschinensprache, Elektronengehirn spricht.

Das war nichts besonderes, haben sicher mehr Leute gemacht. Daher mal so erstmal..
in letzter Zeit hab ich mich damit gar nicht mehr befasst - und MC ist eigentlich simpel und kann wenig , es ist ja auf RISC Prozessoren alles einfaches Zeugs.
sehr logisch und sehr "stumpf" - aber dafür einfach - nur bloß nie Sprünge versauen.

Es gab nicht wenige Programme die sich irgendwo hin verirrt haben oder einfach fest klemmen, weil du ja auch zurück kommen musstest.
Das kostete viele Reset-Drücke ;-)

Mit dem 68K hast du natürlich eh mehr Breite und das ist schon etwas weniger umständlich - allerdings wollte ich meist sehr konkrete Sachen machen, nicht "Mathematik" aber am Ende war es das - total spannend am Ende das Problem irgendwie zu lösen.
 
Meine Erfahrungen mit Assembler waren nur dass ich in der C64-Basic-Zeit immer mal am Rande davon gehört habe… war dann so etwas wie Ehrfurcht, was andere Leute alles können.

Was ich mit der Zeit noch aufgeschnappt habe ist, dass Maschinensprache und Assembler gern mal verwechselt werden… bzw. ich hab es früher immer verwechselt … :P
 
  • Daumen hoch
M.i.a.u.: dcp
die meisten Programme bei mir waren eingebettet in Basic - nur das was schnell sein musste war dann Assembler - besonders in der Zeit wo ich nachgucken musste was was ist.
Das war irgendwann am Spectrum wo es Assembler Programme gab. Da war auch testen einfacher - bis dahin waren es Data Zeilen und sowas. oder man speicherte den Code als "Code" - der Spectrum hatte eine Sicherung und Lademethode genau dafür. Du konntest quasi Code an jede Stelle laden und von jeder Stelle sichern. Das war schonmal sehr hilfreich.
 
Ghidra ist halt bescheuert leistungsfähig, grade das solltest du dir genauer anschauen. Bin echt laie auf dem Thema aber bei youtube findest du sehr viele Videos über Ghidra welche sehr gut erklärt sind.
 
Mich hat die Demoszene damals dazu bewegt Assembler auf dem Amiga zu lernen. Auf dem C64 zuvor wollte ich auch damit beginnen, scheiterte aber schon beim Abtippen eines Assemblers aus der 64er Zeitschrift. Der Amiga war dann DER Computer für Grafik und Sound, auf dem habe ich auch das erste Mal Musik gemacht, selbst gesampelt etc. und auf der Computertastatur die ersten Melodien gespielt. Selbst heute spiele ich viel rein über die Computertastatur ein, obwohl ich ein MIDI-Keyboard habe und in meiner späten Jungend dann auch den ersten Synthesizer. Computer sind daher bis heute für mich eine ganz natürlich Art von Elektronischem Musikinstrument. Mit den Möglichkeiten von heute geht natürlich ein großer Traum von damals in Erfüllung, eben tolle Sounds auch einfach nur ITB machen zu können. Da freue ich mich heute noch jedes Mal wenn ich die DAW anmachen darf.

Nach C64, Amiga, AtariST(ja ich hatte beide Konkurrenten^^) kam dann wie bei allen meinen Freunden der PC, war so Anfang der 90er. Dort habe ich nur wenig x86 Assembler programmiert, da mir das mit den Codesegmenten etc. ein ziemlicher Rückschritt zum wirklich schönen 68000er Assembler vorkam.
Heute mache ich nichts mehr in Assembler, die Erfahrungen von damals haben mir aber unheimlich geholfen, Zeiger in C/C++ zu verstehen, weil diesen Konzept da ja ganz natürlich vorkommt.

Die ganze Assembler Reise auf dem Amiga hat mir geholfen in dem jetzigen Beruf als Entwickler zu arbeiten, da es mir die Augen öffnete was wirklich in einem Computer auf der untersten Programmierschicht passiert. Das ist wie wenn man vorher keine Farben sehen konnte und auf einmal ist alles bunt und man kann so viel neues entdecken.

Vielleicht fange ich auch in nächster Zeit mal mit der Pluginentwicklung an. So meinen eigenen Synthesizer bauen hätte schon was, auch wenn die ersten Versuche sicherlich schrecklich klingen werden, weil ich eben nur 0815 Algorithmen am Anfang kennen lernen werde.
 
Zuletzt bearbeitet von einem Moderator:
Bei mir ist es immer noch der C64...

Mich hat damals auch die Demoscene und die Intros vor den "gecrackten" Spielen fasziniert und das ist heute immer noch so...

Das hat mich dazu bewegt, selbst Assembler zu lern und das geht sogar heute noch etwas hier und da...

Das war das letzte große was ich auf dem C64 gemacht habe...



War ganz lustig nach Jahren des "nicht programmierens" es trotzdem noch hin zu bekommen...

Oder das auch hier...



Board, schon wieder so lang her alles, wie die Zeit vergeht... Übrigens, finde ich es den SID Chip noch immer sehr, sehr geil und ich finde es auch immer wieder interessant, wie die Sounds damals so gemacht worden sind... Analysiere die manchmal wenn ich Zeit und Bock dazu habe....

Wie z.B. das hier:



Frank
 
kybernaut_01 schrieb:
Meine Erfahrungen mit Assembler waren nur dass ich in der C64-Basic-Zeit immer mal am Rande davon gehört habe… war dann so etwas wie Ehrfurcht, was andere Leute alles können.

Was ich mit der Zeit noch aufgeschnappt habe ist, dass Maschinensprache und Assembler gern mal verwechselt werden… bzw. ich hab es früher immer verwechselt … :P
Zum Vergrößern anklicken....
Für die die es nicht wissen:
Assembler Befehle sind Mnemonics, die sind leichter zu merken als die Maschinencodes der Maschinensprache. Ein Assembler ist ein einfacher Übersetzter.
 
1984 hatte ich das erste mal Kontakt mit 6502 Assembler aber richtig beschäftig damit habe ich mich erst ab 1987 mit einem Atari XE.

Ich habe noch Hardware Prototypen "gestrickt": https://de.wikipedia.org/wiki/Fädeltechnik
Auch Gedruckte Schaltungen habe ich hergestellt oder geroutet für Kleinserien von ca. 50 - 150 Stück Mikrocontroller.

Ich habe Bootstrap Loader in Assembler gebaut. Für diverse Prozessoren. Microcontroller. Sogar ein Echtzeit Multitasking Betriebssystem habe ich gebaut. ca. 2000 Zeilen C und Assembler. Auch habe ich ca. 3 einfache Compiler für Virtuelle Maschinen habe ich gebaut. Vor 2 Monaten habe ich einen noch einen erweitert um switch case Anweisungen. Auch habe ich mal den Microsoft Assembler (MASM) mit Makros so erweitert das man damit einen 8085 Programmieren konnte.

Ich habe vor ca. 3 Wochen noch Assembler benutzt um die Prozessor ID auszulesen. Findet man im Internet.

Mit Assembler habe ich den 6502, 8085, 8080, 80386, 68000, 68040, diverse Pic Prozessoren und einen selbstgebauten 8 Bit Prozessor programmiert. Es gibt nicht nur den Maschinencode mit dem man den Prozessor programmieren kann auch der Prozessor führt intern einen Code aus. Den Mikrocode. Damit wird der Maschinecode ausgeführt. Damit habe ich für den gebauten Prozessor programmiert damit er Maschinecode ausführen kann.

Lange her und habe zwar das meiste vergessen aber ich denke etwas kenne ich mich schon noch aus.
 
Abgesehen von erstem BASIC-Versuchen auf meinem CPC464 war mein erster richtiger Assembler "O.M.A.2.0" (was für ein Name) für meinen guten, alten Amiga 500.
Hab zumindest das Buch (v2.0 noch im gediegenen Braunton) hier noch rumschwirren - die Disketten finde ich vielleicht auch noch...
War sehr erhellend im Verständnis des "Innenlebens" einer CPU und hilfreich für spätere Anwendungen mit dem 8051, den ATmegas und etwas später STM32xx.
Vielleicht sollte ich mal das STM32F746-DISCO wieder entstauben - das mit Assembler lass ich hier aber lieber sein...
 
"Assembler" gelernt habe ich mit dem TI-57:
commons.wikimedia.org

File:TI 57.jpg - Wikimedia Commons

commons.wikimedia.org commons.wikimedia.org
(ein programmierbarer Taschenrechner, der so etwas wie z.B. Sprungmarken und Register kannte).
Ca. 1980 war der state-of-the-art im Matheunterricht und hatte sage-und-schreibe 49 mögliche Programmierschritte AFAIR.

<Anekdote>
Matheunterricht: Mein damaliger Mathe-/Physiklehrer war eine fähige coole Socke mit im Schädel eingebautem Rechenschieber.
Im (freiwilligen) Mathe-Aufbauunterricht hat er uns erst Logik (Boolesche Algebra) theoretisch gelehrt - um dann die daraus gewonnenen Erkenntnisse mit echten(!) AND/OR/...Hardware-Komponenten uns im im Physikunterricht nachzubauen zu lassen.
Wir Schüler wussten damals somit, wie ein Computer im Inneren tickt - und genau so(!) kann man junge Menschen für MINT begeistern.
</Anekdote>

Nachdem ich das Grundprinzip von Programmierung verstanden hatte, ging's für mich weiter am Apple ][ - erst BASIC, dann 6502 Assembler - POKE <irgendwas, irgendwohin> - dann CALL <adresse> - und ab ging die Luzi.
 
6502 auf dem ATARI 400, so die ersten Versuche, 68000 auf dem ATARI ST, kleine Routinen, Z80 auf so einem Einplatinen Rechner und x86 unter DOS im Studium.
 
Jeltz schrieb:
.... Hatte mir vor Aeonen mal einen (funktionierenden) MIDI-Analog Stepsequencer in Fädeldraht-Technik gebastelt.
Zum Vergrößern anklicken....
Sieht aus, wie meine Patches, nur in kleineren Dimensionen ...

Da muss man aber wirklich aufpassen, was man tut. Vorbeischlurfende Katzen als Ablenkung sind da, glaube ich, nicht so gut.
 
Zuletzt bearbeitet von einem Moderator:
Ich ungefähr 3 mal. Immer wegen irgendeiner Hard-Realtime-Anforderung. Und nie ohne die Assemblercodierung mit einer Hochsprache zu kombinieren.

Das erste Mal Mitte der 80er Jahre: Für einen Echtzeit-Morsezeichendecoder (hey, der war sogar tempoadaptiv! :)) eine Timer-Interrupt-Routine, in Kombination mit BASIC, auf dem Sinclair ZX Spectrum (Zilog Z80). Mann, was war der Workflow eine Quälerei! Man lernte deshalb gezwungenermaßen, möglichst nichts durch Ausprobieren anzugehen.
Das zweite Mal Anfang der 90er Jahre: Für eine MIDI-Programmierumgebung (dem MidiShare-Framework auf Atari ST bzw. Mac nachempfunden), komplett in der Serial-I/O-Interrupt-Routine, und dazu das - nennen wir es mal - BIOS, in Kombination mit C, auf einem selbst entwickelten Embedded-Controller-Board (Hitachi HD64180).
Das dritte Mal etwa zur gleichen Zeit: Eine Additiv-Synthesizer-Engine in der Audio-Device-Interrupt-Routine, ebenfalls inklusive einer Art BIOS, in Kombination mit C, auf einem selbst entwickelten Audio-Board mit einem der frühen DSPs (AT&T DSP32C).
Die geplante Kombination der beiden letzteren als Standalone-Synth habe ich nie vollendet. Wer weiß, vielleicht wäre es heute ein cooles Erinnerungsstück...

Später war ich eigentlich froh, Assembler nie wieder zu brauchen. C konnte ich auf wirklich jedem Prozessor wiederverwenden - das war genormt, schnell und immer der erste verfügbare Compiler.
 
Plan9 schrieb:
Für die die es nicht wissen:
Assembler Befehle sind Mnemonics, die sind leichter zu merken als die Maschinencodes der Maschinensprache. Ein Assembler ist ein einfacher Übersetzter.
Zum Vergrößern anklicken....
Die erste Zeit habe ich auf meinem ZX Spectrum den Code direkt in Bits bzw. Bytes eingegeben. In Basic die Speicherzellen mit den Bits bzw. Bytes beschrieben. Später hatte ich dann Programme, um Assembler-Befehle in einem Editor einzugeben und auch den Maschinen-Code in den Assembler umzuwandeln. So habe ich z.B. die Maschinensprache aus dem Sample-ROM analysiert und umgeschrieben. Z.B. Load/Save-Prozeduren mit anderer grafischer Darstellung. Zunächst bei Spielen gesehen, dass manche es z.B. in Schwarz-Weiß oder ganz ohne Streifen gemacht haben. Dann auch selber diese Prozeduren entsprechend umgeschrieben und aus dem RAM ausgeführt.
 
Mein Anfang war nachTurbo Pascal Assembler auf dem 386er einfach nur aus Interesse und TSR Programmierung. Ein paar kleine Sachen habe ich programmiert, bin dann aber recht schnell wegen des Wechsels auf OS/2 auf C umgestiegen. Später dann eigentlich nie wieder was mit gemacht, dafür hier und da andere Interpretersprachen ausprobiert. PHP, Python und mittlerweile spiele ich ein bisschen mit Golang und fyne rum. Ne Menge vim und ein büschen bash mit dem drum rum liegenden Toolset.
 
Zuletzt bearbeitet:
dbra schrieb:
Was ich irgendwie krass finde, ist, das Visual Studio jetzt auf Mono basiert und man sich denkt: "Wer übernimmt da jetzt eigentlich wen?"

Hab die Entwicklung jahrelang nicht mehr verfolgt und dann bekommt man nebenbei sowas mit....
Zum Vergrößern anklicken....
Halt nein, , das stimmt so nicht. Steck da jetzt auch nicht soo drin, aber ich denke Du meinst Visual Studio für MacOS, was mit dem Windows VS eigentlich nicht so viel gemeinsam hat ausser dem Namen . Die Mac OS Version ist das ehemalige Mono Develop von Xamarin, dem ehemaligen Mono Entwickler. Xamarin bzw. Mono samt Mono Develop wurde von MS gekauft oder übernommen oder wie auch immer und als Visual Studio für Mac unter Ihrem Namen rebranded. So ...ungefähr :)
 
Zuletzt bearbeitet:
Du musst dich einloggen oder registrieren, um hier zu antworten.


Neueste Beiträge

News

Zurück
Oben