Programmierung

Die Programmierung oder das Programmieren (englisch: programming oder coding) beschreibt im weiteren Sinne die Zusammenstellung einer Reihe von Computerbefehlen mit dem Zweck, den Rechner bzw. das Computersystem zu einem bestimmten, gewollten Verhalten zu veranlassen. Die Liste der eingegebenen Computerbefehle wird in der Regel als Computerprogramm bezeichnet, und derjenige, der die Konzipierung, den Entwurf, also den zugrundeliegenden Algorithmus eines Programms festlegt (diese heutzutage üblicherweise auch eingibt), als Programmierer. Im Heimcomputerbereich ist auch der Begriff Coder nicht unüblich, während man allgemein von einem Programmautor oder mehr im rechtlichen Sinne auch von einem Urheber einer Software spricht.

Info: Auch wenn in der heutigen Zeit die Hürden für das Programmieren scheinbar leicht zu überwinden sind, so bleibt die Erstellung eines umfangreichen und komplexen Computerprogramms aufwändig und benötigt umfangreiche Kenntnisse der verwendeten Hard- und Software, sowie weitere Erfahrungen etwa in Bereichen der Fehlersuche und -behebung, Qualitätssicherung bis hin zum Projekt-Managment!

Allgemeines & Geschichte

Mussten in den Anfängen des Computerzeitalters die Programme noch mit Hand auf Formularkarten geschrieben, von Datentypisten eingetippt und umständlich auf Lochkarten oder Lochstreifen gestanzt und dann in den Computer eingelesen werden, damit eine Verarbeitung durch den Computer möglich ist, benutzen heutige Programmierer für die Eingabe von Computerbefehlen in den Hauptspeicher (kurz: RAM) spezielle Programmierumgebungen oder integrierte Entwicklungsumgebungen (IDE, engl. Integrated Development Environment), die entsprechende Tools, Editoren, Compiler etc. integrieren.

Programme sind in vereinheitlichten (und damit leicht erlernbaren oder verbreiteten) Programmiersprachen wie BASIC, Pascal, Comal, Assembler, usw. abgefasst, können aber auch ganz obskure Formen annehmen, die nur für spezielle Zwecke vorgesehen sind (z.B. Maschinensteuerungen, Lichtsteueranlagen) oder ein gewisses Programmierparadigma, etwa funktionale oder logische Programmierung, bedienen.

Hinweis: Nach der Eingabe von Programmen in den Hauptspeicher (der üblicherweise nach dem Ausschalten des Computers seine Daten verliert) müssen Programme unbedingt auf einen Datenträger abgespeichert werden!

Systematische Programmierung

Im engeren Sinne ist Programmierung die Lösung von algorithmischen Problemen an einem Computer. Hierzu gehören u.a. das Erfassen des Problems, seine Zerlegung in kleinere Teilprobleme, die Veranschaulichung der Teilprobleme als Ablaufskizze und Flussdiagramm, die Umsetzung und das Eingeben der Befehle in einer beliebigen (geeigneten) Programmiersprache, ggf. das Kompilieren des Programms und das anschließende Testen einschließlich Fehlersuche (engl. debugging).

Bei großen Softwareprojekten (Entwicklung von Anwendungen oder Computerspielen) ist es notwendig, einen guten Programmierstil zu benutzen. Dazu gehören neben einer guten Dokumentation ebenso eine nachvollziehbare Programmierung mit entsprechenden Anmerkungszeilen (via REM), das sinnvolle Einrücken von Programmzeilen (falls es die Programmiersprache erlaubt), z.B. bei Schleifen, die laut Sprachdefinition vorgesehene exakte Nutzung der Befehle, sowie die Nutzung von sprechenden Variablennamen (wie Hintergrundfarbe anstelle von F oder F1).

Speicherplatzsparende Programmierung

In den Anfängen des Computernutzung war Speicherplatz, insbesondere der wichtige Arbeitsspeicher, teuer. Daher wurde bei umfangreichen Computerprogrammen häufig getrickst, um Platz zu sparen. Möglichst viele Befehle wurden ohne trennende Leerzeichen und ohne erklärende Bemerkungen in eine Zeile gepackt, möglichst kurze Variablennamen genutzt, verzichtbare Befehle weggelassen wie z.B. LET oder auch END. Diese platzsparende Art der Programmierung gilt wegen seiner schlechten Nachvollziehbarkeit als schlechter Programmierstil (sogenannter "Spaghetti-Code"). Jemand, der beruflich ein solches Programm warten müsste, hätte damit Schwierigkeiten, wodurch ein wirtschaftlicher Nachteil entstünde.

Beispiele für Programme

Listing für C64 in BASIC 2.0

• Für C64 als BASIC 2.0 Programm

10 REM *** C64-WIKI STERNE DEMO ***
15 REM * REM-Zeilen brauchen nicht mit eingegeben werden ! *
20 PRINT CHR$(147); "!!! DAS C64-WIKI STERNE DEMO !!!"
25 REM * Setzen der Bildschirmhintergrund- und Rahmenfarbe (bei Start ist FARBE=0 )
30 POKE 53280,FARBE : POKE 53281,PEEK(53280)
35 REM * Ermittelung einer Zufallszahl in Variable FARBE
40 LET FARBE = INT( RND(1) *16)
45 REM * Setzen einer zufälligen Schriftfarbe mit FARBE
50 POKE 646, FARBE
55 REM * Zufällige Positionierung des Cursors
60 POKE 211, INT( RND(1) *40) : POKE 214, INT( RND(1) *24) : SYS 58640 
65 REM * Setzen eines Sternes auf dem Monitor
70 PRINT "*";
75 REM * 1/25 Chance, dass Hintergrundfarbe geaendert wird 
76 REM * durch Rücksprung nach Zeile 30
80 IF RND(1) < 1/25 THEN GOTO 30
85 GOTO 40: REM Rücksprung nach Zeile 40
90 REM *** ABBRUCH NUR MIT RUN/STOP-Taste !!! ***
95 END: REM * Nicht obligatorisch, kann entfallen *

Speicherplatzsparendes Listing, aber schlechter Programmierstil

• Gekürztes, platzsparendes Programm, das dasselbe bewirkt, in kompakter Form für C64:

1 PRINT"{clr}!!! DAS C64-WIKI STERNE DEMO !!!":GOTO4
2 F=INT(RND(1)*16):POKE 646,F:POKE211,INT(RND(2)*40):POKE214,INT(RND(3)*24)
3 SYS58640:PRINT"*";:IFRND(1)>=.04THEN2
4 POKE53280,F:POKE 53281,F:GOTO2

• Variante, die noch mehr auf Kürze und Geschwindigkeit getrimmt ist:

1 print"{clr}!!! das c64-wiki sterne-demo !!!":s=4^5:c=s*54:d=53280:e=d+1
2 f=rnd(1)*16:o=rnd(1)*1e3:pokec+o,f:pokes+o,42:ifrnd(1)>=.04then2
3 poked,f:pokee,f:goto2

Listing in C für cc65

• Programm mit ähnlicher Anzeige in C für cc65:

#include <stdlib.h>
#include <conio.h>

void main(void)
{
    unsigned char breite, hoehe;
    unsigned char hintergrund_alt, rahmen_alt, text_alt;
    unsigned char farbe = COLOR_BLACK;
   
    _randomize();
    screensize(&breite, &hoehe);
    clrscr();
    hintergrund_alt = bgcolor(farbe);
    rahmen_alt = bordercolor(farbe);
    text_alt = textcolor(COLOR_YELLOW);
    cputs("!!! Das C64-Wiki Sterne Demo !!!");
    while (! kbhit()) {
        farbe = rand() % 16;
        textcolor(farbe);
        cputcxy(rand() % breite, rand() % hoehe, '*');
        if (rand() % 100 <= 1) {
            bgcolor(farbe);
            bordercolor(farbe);
        }
    }
    cgetc();
    bgcolor(hintergrund_alt);
    bordercolor(rahmen_alt);
    textcolor(text_alt);
    clrscr();
}

Beispiel in Forth

• Und das Ganze nochmal für volksFORTH in zwei aufeinanderfolgenden Blöcken, wobei der erste Befehle zum Erzeugen von Zufallszahlen enthält:

\ Random Numbers

\ The algorithm is ported from cc65.

| create seed 5 allot

: seed! ( n -- )
  seed 5 erase  seed 3+ ! ;

: seed@ ( -- n ) seed 3+ @ ;

: random ( -- n )
  seed 1+ 2@  seed 2@ d+
  $3.1415927 d+  seed 1+ 2!  seed 2+ @ ;

: randomize ( -- )
  $d012 c@ 256 *  $a0 c@ or  seed! ;

: randint ( max -- n ) random swap mod ;

1 seed!

\ Sterne-Demo Main

-1 +load  \ random

: random-color ( -- n ) 16 randint ;
: text-color! ( n -- ) 646 c! ;
: border-color! ( n -- ) 53280 c! ;
: background-color! ( n -- ) 53281 c! ;

: sterne-demo ( -- )
  randomize
  page ." !!! C64-Wiki Sterne-Demo !!!"
  begin
    random-color
    dup text-color!
    l/s randint  c/l randint  at
    ascii * emit
    100 randint 2 <
    if
      dup border-color!
      background-color!
    else drop then
  stop? until
  cold ;

Beispiel in Assembler

• Wegen der hohen Geschwindigkeit wurde hier auf die Textausgabe und auf das Ändern der Hintergrundfarbe verzichtet.

       ; Programm: Sternenhimmel
       ; Start: SYS 49152
       ; ACME:   "acme.exe -o sterne.prg -f cbm sterne.asm" 
       ; 64TASS: "64tass.exe -o sterne.prg sterne.asm"

       *= $c000         ; Startadresse 49152 oder $c000
start  lda #147         ; Bildschirm löschen
       jsr $ffd2

       lda #$00         ; Bildschirm schwarz
       sta $d020
       sta $d021

       lda #$81         ; SID-Tongenerator - Stimme 3
       sta $d412        ; Wellenform = Rauschen

       lda $d012        ; aktuelle Rasterstrahlposition auslesen (SEED)
       ora %10000000    ; MSB setzen, für hohe Frequenzen
       sta $d40f        ; oberes Frequenz-Byte setzen - Stimme 3

                        ; Zufallszahl $0400...$07e7 bzw. $d800...$d8e7    
endlos ldx $d41b        ; Zufallswert holen (Oszillator3)
       stx $fb          ; Bildschirmposition Low-Byte
       stx $fd          ; Farb-Ram-Position Low-Byte

       lda $d012        ; Zufallswert holen (Rasterstrahlposition)
       and #%00000011   ; Wertebereich $00-$03 
       ora #%00000100   ; Wertebereich $04-$07
       sta $fc          ; Bildschirposition High-Byte $04-$07

       and #%00000011   ; Wertebereich $00-$03
       ora #%11011000   ; Wertebereich $d8-$db
       sta $fe          ; Farb-Ram-Position High-Byte $d8-$db

       cmp #%11011011   ; wenn Wertebereich 
       bne weiter       ;      $dbe8...$dbff
       cpx #$e8         ; bzw. $07e8...$07ff
       bcs endlos       ; dann wiederholen

weiter ldx #$00
       lda #'*'         ; Sternchen in      
       sta ($fb,x)      ; Bildschirmspeicher schreiben

farbe  lda $d41b        ; Zufallswert holen (Oszillator3)
       and #%00001111
       beq farbe        ; wenn schwarz, dann nochmal
       sta ($fd,x)      ; zufällige Farbe 1-15 ins Farbram schreiben 

taste  jsr $ffe4        ; Taste gedrückt?
       beq endlos       ; nein -> Sprung nach endlos
       rts              ; ja -> Rücksprung ins BASIC

Weblinks

• Programmieren mit dem C64 - bei 64er Online
• Programmierung - bei Retro-Programming (Webarchiv)
• C64 - im Technology Blog
• The Lost Ways of Programming: Commodore 64 BASIC