Mit dem programmieren ist schon so eine Sache.
Ich selbst habe einen C64 seit 1984 und am Anfang damit hauptsaechlich
gespielt und irgendwann 1988 ? mit Basic 2.0 angefangen.
(Ich war da noch ziemlich jung))
Das war als Basic recht performant aber auch spartanisch.
Dann kamen die ueblichen Verdaechtigen, wie
Exbasic Level 2 - auch performant aber hauptsaechlich neues im Bereich program-control.
Simons Basic - von den Features ein gigantischer Fortschritt, aber langsam
Paradox Basic - kleine Befehlserweiterung, dafuer wesentlich mehr freier RAM, brauchte man aber irgendwie nicht.
Austro Compiler - Basic Compiler aber problembehaftet und nur maessige Beschleunigung
Man darf sich das nicht wie heute vorstellen. C64 in der DDR, ich hatte nur das
Bedienungshandbuch und das Programmierhandbuch und Software aus dritter Quelle.
Man konnte nicht mal eben irgendwo Disketten kaufen...
Gegen 1990/91 also nach der Wende habe ich haeufig Zeit nach der Schule auf der
Arbeitsstelle meines Vaters verbringen muessen und die Beschaeftigungsmoeglichkeiten waren begrenzt.
Oft sass ich vor dem 386SX-16 und Norton Commander und die Spiele waren doch sehr begrenzt.
Ich glaube es war Alleycat, Sokoban, Rockford, Blockout und Flight Simulator 4.
Dabei war FS4 noch am interessantesten, wegen der im Vergleich zum C64 hoeheren Aufloesung und
Vektorgrafik.
Irgendwann entdeckte ich Turbo Pascal 6 auf der Festplatte und wie es so kommt,
wollte ich auch mal schauen wie man die High-Res Grafik von 640x480x16 auf den
Schirm bekommt und irgendwas damit machen. Man kann sich vorstellen, dass das doch
eine grosse Umstellung war zum Basic des C64. Integrierte IDE, andere Syntax,
geht nur mit Compiler und gleich mal Unit Graph fuer sein erstes TP Programm nehmen zu wollen...
Ich glaube ich habe meinen Vater mit meinen Fragen da ziemlich beim arbeiten gebremst.
Aber irgendwann hat es funktioniert und die ersten putpixel brachten bunte Punkte auf den Schirm.
Kurz darauf habe ich mit Assembler auf dem C64 angefangen, damals auch noch rein aus dem
Programmierhandbuch. Das hat eigentlich damit angefangen, dass ich mir ein Final Cartridge III geleistet habe,
mit integrierten Monitor + Freezer um anderen Code zu klauen aehh analysieren.
Tja was kam noch in der Zeit. Erfahrung mit Turbo Pascal 3.0 (Turtle Grafik, wer kennt die noch?),
Turbo Pascal 5.5, Power Basic (kompilierendes Basic) und so 1994 herum auch etwas Assembler auf dem PC.
Was kam dabei heraus? Naja so DYCP, DCLP, DYPP in Tweaked Modes und Fullscreen Plasma, irgendwelche Roto Zoomer und
bisschen Voxelspace. SWAG (per Download aus Mailbox) und PC Intern 3.0 sind so bekannte Sachen.
Mit dem Borland Pascal 7 beiliegenden Turbo Pascal fuer Windows 1.0 konnte ich mich nie so recht anfreunden.
Dafuer habe ich auch mal in Turbo Vision reingeschnuppert. Das ist das gleiche UI wie die IDE.
Dann kam ein recht grosser Schwenk und ich habe mit Java angefangen, was damals brandneu war.
Und Applets fuer den damals noch Interpreter unter Netscape 2.0 geschrieben mit notepad und
Kommandozeilencompiler. Und es war auf meinem Pentium 100 doch recht lahm. Aber das
hat mich nicht abgeschreckt, weil das Konzept was dahinter steht doch sehr modern war fuer 1995.
Zwischendurch gab es neben Java auch immer mal Stellen, wo ich mal was in TP7 oder Delphi gemacht habe.
Schlimm aehh gewoehnungsbeduerftig fand ich auch das programmieren unter Labview 6.1 / 8.0.
Das ist grafisch.
Zu C bin ich erst sehr spaet gekommen, so am Ende meines Studiums. Habe da aber nicht soo viel gemacht.
Insbesondere neu war in dem Moment, dass ich wieder direkt mit dem Pointern hantieren musste, was in Java
nicht so ist (managed). Genaugenommen war es C fuer Win32.
Danach kam verblueffenderweise die Gelegenheit wieder mal 6502 Assembler fuer C64 / C128 zu programmieren als
Prototyp Plattform fuer eine Hardware.
Wens interessiert C128 schafft ca. 3 kHz samplen von ADC ueber SPI mit speichern auf Festplatte und gleichzeitiger grafischer
Darstellung auf dem VDC (752x288). Der schiebt auch mal ne Diskette von der 1581 im Burstmode ueber seriell als *.d81.
Naja egal, wo ich jetzt dran sitze ist sowas auf einem Freescale DSP 568367 zu realisieren. Das ist ein ziemliches Geschoss.
Zu den TP Sachen habe ich nicht viel im Netz stehen.
Paar Sachen zu Java:
eines meiner ersten Spiele (ca. May 1997):
http://mail.lipsia.de/~enigma/giana/giana.html
anderer Krams:
http://mail.lipsia.de/~enigma/java/java.html
Bitte beachten, dass es teilweise wirklich alt ist.
Fuer die Katakis Fans:
http://mail.lipsia.de/~enigma/javakis/test.html
Und das ist etwas ernster, eines der letzteren Projekte:
http://mail.lipsia.de/~enigma/jstml/JST ... ation.html
Meine Meinung zu den Programmiersprachen:
Viele der kleinen Alltagsprobleme lassen sich in kurzen strukturierten Programmen loesen.
Vor modernen Programmiersprachen kann man sich nicht auf Dauer verschliessen, weil man haeufig mit
anderer Software zusammenarbeiten muss. Wenn es da nur Routinen fuer bestimmte Programmiersprachen gibt, hat man ein Problem.
Das heisst nicht, dass Assembler tot ist, es ist nur fuer bestimmte Sachen unpraktikabel.
Es gibt auch Programme, da ist die Ausfuehrungsgeschwindigkeit fast egal, aber nicht die Entwicklungsdauer.
Wo ich immer Schwierigkeiten habe, ist bestimmten Abstraktionen zu folgen in Hochsprachen. Bei Turbo Pascal ist der Zusammenhang
im Ablauf einer TP-Prozedur und dem dahinterliegendem Maschinencode noch ersichtlich. Bei abstrakteren Hochsprachen aber nichtmehr.
Das heisst aber oft, dass man klassisch bestimmte Dinge in der Hochsprache in einem maschinennahen Stil programmiert.
(z.B. Schleife um fuer jedes Element etwas zu tun)
Nun gibt es da teilweise Funktionen die das auf einmal machen, fuer das obige Beispiel z.B. irgendeine Art Listenfunktion.
Uebertrieben: Der Listenfunktionsaufruf ist eine Zeile und 100x schneller als die Schleife in vielleicht 5 Zeilen. Effektiv macht beides das gleiche.
Das aergert mich dann. Vor allem wenn man weiss, wenn man die Schleife etwas spezieller macht, gibt es keine fertige Listenfunktion mehr, die die
Funktionalitaet abbildet.
Bei Labview wird sowas ganz extrem, wo man dann Funktionsbloecke hat fuer beispielsweise ein externes Geraet, wo massig Code drin steckt.
Jedoch dann um zwei Zahlen zu addieren ein Addiersymbol und ein paar Leitungen mit der Maus ziehen muss, was umstaendlich, ineffektiv, unuebersichtlich ist.
Fuer die nicht Labview Kenner - man stelle sich vor sein Programm auf einem Blatt Papier wie eine elektronische Schaltung aufzumalen.
Statt C = A + B nimmt man ein Addierblock, der zwei Eingaenge und einen Ausgang hat, kabelt A und B an die Eingaenge und C an den Ausgang.
Zur Bedienung, vor allem auch unter den bekannten GUIs:
Die Maus hat auf jeden Fall ihre Daseinsberechtigung, man denke nur an Bildverarbeitung.
Was viele Entwickler aber verkennen - es ist und bleibt ein Zeigeinstrument.
d.h. Tastenkuerzel sind genauso wichtig wie frueher, ich denke da z.B. an Wordstar.
Tastenkuerzel sind wesentlich effektiver als mit der Maus irgendwohin zu fahren und zu klicken.
(und die Hand von und wieder zur Tastatur zu bewegen)
Wenn man nun Tastenkuerzel weglaesst, schraenkt man damit stark die Bedienbarkeit einer Applikation ein.
Man verbaut sich sozusagen den Zugriff ueber das Eingabehauptinstrument.
Es gibt aber auch andere Sachen.
Hat sich schonmal jemand ueberlegt wie man unter Windows persistente Spaltenbloecke markieren kann?
Nur mal angenommen man hat Messdaten, die an festen Positionen stehen und man will die dritte Datenspalte herauskopieren.
Beispielsweise waere das Spalte 10 bis 15 und 1000 Zeilen.
Unter Wordstar markiert man einfach einen persistenten Spaltenblock.
Unter Windows hmmm, versucht man das File in Excel zu importieren um dann eine Datenspalte wieder herauszukopieren.
Ist das wirklich besser?
Irgendwie ist die Bedienungseffizienz mit den GUIs gesunken und es gibt momentan so eine Art Konzeptlosigkeit.
Da kann man sich dann bei einem der Multimediakeyboards hinter eine Spezialtaste ein Makro legen, was eine Mausfunktion auf Tastendruck ausfuehrt,
weil fuer die Funktion keine Tastaturauswahl vorgesehen ist....
Dann ist das Scrollrad gekommen, was primaer fuer Webseiten praktisch ist. Bei Texten braeuchte man es nicht zwingend.
Neuerdings gibt es auch Mause wo man das Scrollrad nach links und rechts druecken kann....
... vermutlich weil das Seitendesign der Webseite es so benoetigt. ;)
So und nun nochwas fuer die Pascal Freunde von 1996:
Code: Alles auswählen
{ Das ist ein Textmodus Scroller, welcher Probleme bei der Anzeige hat:
Der Source ist IMO gut dokumentiert
Die eingeklammerten Pascalzeilen im Assemblerteil
entsprechen den darüberbefindlichen ASM-Anweisungen
}
{$N+,E-,G+,X+}
uses dos,crt;
const
{Nur die Farben}
sfx : array [0..2,0..79] of byte =
((06,04,12,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,12,04,06),
(06,04,12,14,14,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,
15,15,15,14,14,12,04,06),
(06,04,12,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,
14,14,14,14,14,12,04,06));
var
scrt : array [0..255] of word; {Scrolltext}
sc1 : array [0..255] of word; {Dehnung}
chs : pointer;
s : string;
reg : registers;
anzc,sinpos,adr,z1,z2,z3,p1,p2,p3,z4 : word;
pan,z : byte;
w,p : word;
begin
s:=' '+
'Dieser Scroller ist im Textmodus geschrieben und hat einige Anzeigeprobleme - nur W'+
'ARUM ??? wrap '+
' ';
{Scrolltext in Byte-Array}
for z:=0 to 255 do scrt[z]:=ord(s[z]);
{Textbildschirm vollmachen}
z3:=0;
for z1:=0 to 79 do begin
for z:=0 to 2 do begin
w:=(z+6)*80+z1;
memw[$b800:w shl 1]:=sfx[z,z1] shl 8 + z3;
w:=(z)*80+z1;
memw[$b800:w shl 1]:=sfx[z,z1] shl 8 + z3;
w:=(z+3)*80+z1;
memw[$b800:w shl 1]:=sfx[z,z1] shl 8 + z3;
w:=(z+9)*80+z1;
memw[$b800:w shl 1]:=sfx[z,z1] shl 8 + z3;
inc(z3);
end;
end;
{Auf 8-Punkte Darstellung umschalten}
reg.bx:=0001;
z:=port[$3cc] and not(4+8);
port[$3c2]:=z;
inline($fa); {CLI}
portw[$3c4]:=$0100;
portw[$3c4]:=$01+reg.bl shl 8;
portw[$3c4]:=$0300;
inline($fb); {STI}
reg.ax:=$1000;
reg.bl:=$13;
intr($10,reg);
reg.ax:=$1110;
reg.bx:=$2000;
reg.cx:=$0100;
reg.dx:=0;
reg.es:=$a000;
reg.bp:=0;
intr($10,reg);
gotoxy(1,1);
{Zeichensatzzugriff herstellen}
inline($fa); {CLI}
{egavga_sequenzer}
portw[$3c4]:=$0100;
portw[$3c4]:=$0402;
portw[$3c4]:=$0704;
portw[$3c4]:=$0300;
{Graphicscontroller}
portw[$3ce]:=$0204;
portw[$3ce]:=$0005;
portw[$3ce]:=$0406;
inline($fb); {STI}
for p:=0 to 8192 do begin
mem[$a200:p]:=mem[$a000:p]; {orig. Zsatz nach chs kopieren}
mem[$a000:p]:=0; {Löschen von aktuellem ZS}
end;
pan:=0;
adr:=0;
for z:=0 to 255 do sc1[z]:=Round(3*(sin(z/10)*cos(z/5))+3); {Buchstaben-Dehnen-Sinus}
asm
mov di,0a000h
mov es,di
{repeat}
@mainloop:
mov sinpos,1
@incsinpos:
{for sinpos:=1 to 64 do begin {Bewegen}
{Auf Retrace warten}
mov dx,3dah
@wait1:
in al,dx
test al,8h
jz @wait1
@wait2:
in al,dx
test al,8h
jnz @wait2
xor di,di
xor ax,ax
mov cx,2048
cld
db $f3,$66,$ab
mov anzc,1
{ for anzc:=1 to 80 do begin {Alle 80 Zeichen bearbeiten}
@alle80:
mov ax,anzc
mov bx,ax
shl ax,6
shl bx,5
add ax,bx
mov p,ax
{ p:=anzc shl 6+anzc shl 5; p*96}
mov si,offset scrt
mov bx,adr
add bx,anzc
shl bx,1
mov ax,ds:[si+bx]
shl ax,5
mov w,ax
{ w:=st[adr+anzc] shl 5}
xor dx,dx {dx=z4}
xor ax,ax {ax = z = 0}
{ z:=0;}
{ for z4:=0 to 15 do begin }
@alle15:
mov si,offset sc1
mov bx,sinpos
add bx,dx
add bx,anzc
shl bx,1
add ax,ds:[si+bx]
{ p2:=round(sc1[sinpos+z4+anzc]); }
{ ax= z :=z+p2;}
mov bx,ax
add bx,dx
add bx,p
mov di,bx
mov bx,w
mov cx,$a200
push ds
mov ds,cx
add bx,dx
mov si,bx
movsb
pop ds
{ mem[$a000:p+z4+z]:=mem[$a200:w+z4];}
inc dx
cmp dx,16
jne @alle15
{ end; }
inc anzc
cmp anzc,81
jne @alle80
{ end;}
mov dx,$03c0
mov al,$33
out dx,al
mov al,pan
out dx,al
inc pan
{ port[$3c0]:=$33;
port[$3c0]:=pan;}
cmp pan,9
jne @danach
xor al,al
mov pan,al
inc adr
cmp adr,176
jne @danach
xor ax,ax
mov adr,ax
@danach:
{ if pan=8 then begin {Smooth-Scrollen
pan:=0;
inc(adr);
if adr=175 then adr:=0;
end
else inc(pan);}
inc sinpos
cmp sinpos,65
jne @incsinpos
mov dx,$0060
in al,dx
cmp al,57
jne @mainloop
{until port[$60]=57;}
end;
{Alles wiederherstellen}
portw[$3c4]:=$0100;
portw[$3c4]:=$0302;
portw[$3c4]:=$0304;
portw[$3c4]:=$0300;
{Graphicscontroller}
portw[$3ce]:=$0004;
portw[$3ce]:=$1005;
portw[$3ce]:=$0e06;
asm
mov ax,3
int 10h
end;
end.
{P.S.: Vielleicht kennt das jemand vom C64 ;-) }
Uhm naja der Code ist vielleicht doch nicht so doll.