64 für Profis

64 für Profis
	Sprache	deutsch
	Autor(en)	Michael Angerhausen, Becker, Klaus Gerits, Wolfgang Schellenberger
	Verlag	Data Becker
	Jahr	1983, 1984
	ISBN	ISBN 3-89011-007-X
	Neupreis	49 DM
	Datenträger
	Seitenzahl	302 S.
	letzte Auflage	2., überarbete u. erweiterte Auflage
	Genre	Programmieren
	Information

Inhaltsverzeichnis

Vorwort ................................................ 1

Inhaltsverzeichnis ..................................... 3

EINLEITUNG - Programmieren Profis andern ?.............. 7

1. Kapitel:

1. Bevor Sie anfangen zu Programmioren.................. 11
1.1 Das sollten Sie sich ersparen ...................... 11
1.2 Die Programmidee ................................... 13
1.3 Der Programmentwurf ................................ 20
1.3.1 Das Flußdiagramm ................................. 20
1.4 Vorbereltungsarbelten  zur Programmierung........... 34
1.4.1 Die Gestaltung der Bildschirmmaske ............... 34
1.4.2 Die Festlegung der Dateien ....................... 37
1.4.3 Rechenformeln .................................... 41
1.4.4 Die Druckausgabe ................................. 43
1.4.5 Die Variablenliste und Tips zum Umgang mit
      Variablen ........................................ 43
1.4.6 Die Programmdokumentation ........................ 47
1.4.7 Grundsätzliche Überlegungen zum Programmaufbau ... 49
1.5 Strukturiertes Programmieren an einem Beispiel-
    Der COMMODORE 64 als Taschenrechner ................ 51
1.5.1 Vorbereitungen ................................... 52
1.5.2 Die Programmanalyse .............................. 52
1.5.3 Die Varlablenliste ............................... 54
1.5.4 Der Programmablauf ............................... 55
1.6 Das Struktogramm ................................... 64
1.7 Flußdiagramm  kontra Struktogramm .................. 84
1.8 Erstellen des strukturierten BASIC-Listlngs ........ 85

2. Kapitel:

2. Ein Programm besteht aus drei Dingen ................ 93
2.1 Dateneingabe ....................................... 94
2.1.1 Die Bildschirmmaske .............................. 95
2.1.2 Eingabefelder .................................... 98
2.1.3 Cursorpositionierung ............................. 104
2.1.4 Tastaturübernahme ................................ 106
2.2 Datenverarbeitung .................................. 111
2.2.1 Variable ......................................... 112
2.2.2 Rechengenauigkeit ................................ 114
2.2.3 Sortieren ........................................ 113
2.3 Datenausgabe ....................................... 123
2.3.1 Ausgabe auf Floppy ............................... 124
2.3.1.1 SEQ ............................................ 125
2.3.1.2 REL ............................................ 127
2.3.1.3 ISAM ........................................... 135
2.3.1.4 QUISAM ......................................... 139
2.3.1.4.1  Der Hashcode ................................ 141
2.3.1.4.2 Dateigröße ................................... 146
2.3.1.4.3 Eintrag  löschen ............................. 158
2.3.1.4.4  Satz eintragen .............................. 166
2.3.1.4.5 Satz suchen .................................. 170
2.3.1.4.6 Wofür eignet sich QUISAM ..................... 173
2.3.2 Die Ausgabe auf Drucker .......................... 175
2.3.2.1 Drucker gleich Drucker? ........................ 175
2.3.2.2 Tabulator ...................................... 178
2.3.2.3 Dezimalpunkte .................................. 178
2.3.2.4 Formatierung ................................... 179

3. Kapitel:

3. Tips für die professionelle  Programmgestaltung
   In diesem Kapitel zeigen Mir  Ihnen anhand
   ausgewählter, wichtiger Themenbereiche wie
   Sie Ihre Programme noch bediener - und
   anderungsfreundlIcher  gestalten  können ............ 157
3.1 Parameterisierung  von Programmen .................. 187
3.2 Menüsteuerung  und Overlaytechnik .................. 192
3.3 Mehr Programmkomfort  durch Funktionstasten ........ 196
3.4 Testen Sie Ihr Programm aus - Anwender sind
    keine Versuchskaninchen! ........................... 199
3.5 Die Bedienungsanleitung, das Aushängeschild
    eines Programms .................................... 202
3.6 TOP-DOWN oder BOTTOM-UP ............................ 208
3.7 Logische Felder - 8 Entscheidungen  pro Byte ....... 211
3.8 Das Datum - der besondere Datentyp ................. 214
3.9 Daten gepackt speichern ............................ 217

4. Kapitel:

4. Anwendungsprogramme ................................. 221
4.1 Einleitung ......................................... 221
4.2 Eine parameterisierte LagerVerwaltung .............. 223
4.3 Ein universeller  Reportgenerator .................. 245
4.4 Ein einfaches Textverarbeitungsprogramm ............ 230
4.3 QUISAM konkret - eine Literaturstellen-
    verwaltung ......................................... 239
4.6 Eine komfortable AdressenVerwaltung ................ 273

5. Kapitel:

5.1 Die Verwendung  von Programmlerhilfen  am
    Beispiel  von MASTER 64 ............................ 280
5.2 Strukto 64 ......................................... 290
5.3 Das Strukto 64 Grafikkonzept ....................... 297

Vorwort

Mit "64 für Profis" können wir Ihnen bereits den siebten Titel in der beliebten Reihe der DATA BECKER BÜCHER vorlegen. Das Erscheinungsdatum dieses Buches fällt zusammen mit einer Zahl, auf die wir besonders stolz sind:

In nur 10 Monaten konnten wir über 100.000 DATA BECKER Bücher verkaufen.

Auch bei "64 für Profis" hat sich unser Autorenteam wieder größte Mühe gegeben, Ihnen fundierte Ratschläge und Anwendungen zu geben, die Ihnen helfen, Ihren COMMODORE 64 optimal einzusetzen.

Anwendungsprogrammierung in BASIC für Fortgeschrittene ist das Thema dieses Buches. Vom Programmentuwurf über Menuesteuerung, Bildschirmmaskenaufbau, Farameterisierung, Datenzugriff und Druckerausgabe bis hin zur Dokumentation wollen wir Ihnen mit vielen Beispielen zeigen, wie qgute Anwendungsprogrammierung in BASIC vor sich geht. Besonders stolz sind wir dabei auf die von Klaus Gerits entwickelte neue Dateizugriffsmethode QUISAM.

Neben den auf dem Titel vermerkten Autoren, die Ihnen alle bereits von anderen DATA BECKER BÜCHERN bekannt sein dürften, halfen bei der Erstellung dieses Buches die Herren Englisch, Froitzheim, Kausmann und Retzlaff. Die Zeichnungen stammen von Frau Jordan. Ihnen allen gilt unser besonderer Dank.

Viel Spaß bei der Lektüre dieses Buches wünschen

Ihre Autoren

Leseprobe

(1. Auflage - Seite 199: Kapitel "Kapitel 3: Tips für die professionelle Programmgestaltung"; Unterkapitel "5.4 Testen Sie ihr Programm aus - Anwender sind keine Versuchskaninchen")

Nichts ist wohl in der Programmierung schlimmer, als ein Anwender, der Sie laufend telefonisch mit neuen Fehlermeldungen beglückt, und Sie dann irgendwann vielleicht sogar mit seinem Anwalt bedroht. Das muß und darf nicht so sein ! Professionelle Programme sollen, bevor sie in die Hand des späteren Anwenders gelangen, sorgfältig ausgetestet werden. Was zunächst nach lästiger Mehrarbeit aussieht, ist in Wirklichkeit eine wichtige Arbeitserleichterung. Dies gilt natürlich insbesondere dann, wenn Sie ein und dasselbe Programm mehreren Anwendern zur Verfügung stellen.

Der Vorgang des Testens beginnt sinnvollerweise bereits bei der Programmerstellung. Testen Sie jeden Programmteil und jedes Unterprogramm nach Fertigstellung zunächst isoliert mit willkürlich gewählten Daten und dann erst im Programmzusammenhang. So ersparen Sie sich später eine langwierige Fehlersuche. Der Vorteil einer strukturierten Programmierweise und die Arbeit mit erprobten Bausteinen kommen hierbei voll zur Geltung. Sehr hilfreich für das Austesten von Programmen sind die im COMMODORE 64 Befehlssatz leider nicht vorhandenen, sogenannten TOOLKIT-Befehle, wie z.B. TRACE, FIND und DUMP. Besonders der Befehl TRACE, der die jeweiligen Programmbefehle bei der Ausführung auf dem Bildschirm anzeigt, erweist sich als sehr nützlich. Die TOOLKIT-Funktionen sind in den unterschiedlichen zum COMMODORE 64 erhältlichen Befehlserweiterungen enthalten. Achten Sie bei der Auswahl der entsprechenden Befehlserweiterungen unbedingt darauf, daß die TRACE-Funktion wahlweise auch Einzelschrittverarbeitung zuläßt.

Sehr wesentlich ist das Erstellen der Dokumentation paralell zur Programmierung. Eine erst nach Programmfertigstellung verfaßte Dokumentation weist nicht nur oft Vergeßlichkeitslücken auf, sondern ist schon fast Verschwendung. Bei der Fehlersuche, aber auch bei der Verhinderung dar Fehlarentstehung ist die Dokumentation ein sehr wesentliches Hilfsmittel. Denken Sie z.B. einmal an den häufigen und typischen Fehler der Mehrfachdefinition von Variablen. Mit einer ordentlich geführten Variablenliste kann soetwas nicht passieren. Auch Dateibeschreibungen und Bildschirmmasken sollten vor der eigentlichen Programmierung erstellt werden. Für viele Programmierer ist leider das Erstellen einer Dokumentation eine lästige Pflichtübung, die lange nach Programmerstellung mehr schlecht als recht vorgenommen wird. Gewöhnen Sie sich diese Unart bitte gar nicht erst an !

Bei hartnäckigen Fehlern, die auch mit intensiver Testarbeit manchmal nicht oder nur sehr schwer zu finden sind, kann es durchaus ratsam sein, die entsprechende Problemstellung noch einmal anders programmtechnisch zu lösen. Leider kann es auch immer wieder vorkommen, daß ein solcher unerklärlicher Fehler auf eine Unzulänglichkeit im Betriebssystem des COMMODORE 64 oder seiner Peripherie zurückzuführen ist. Da helfen dann nur Pragrammänderungen Ihrerseits, die derartige Fehlerquellen umgehen.

Noch ein anderer Punkt sollte beim Testen, vor allem des fertigen Programms, berücksichtigt werden. Hierzu ein aktuelles Beispiel: das in diesem Buch dargestellte Dateizugriffsverfahren QUISAM wurde von Ersteller Klaus Gerits nach allen Regeln der Kunst getestet und für fehlerfrei befunden. Damit wäre es beinahe in der ursprünglichen Version in dieses Buch gekommen. Doch wir hatten (geplantes) Glück. Eins der im letzten Teil des Buches vorhandenen Anwendungsprogramme sollte den Gebrauch von QUISAM illustrieren. So schrieb Wolfgang Schellenberger auf Basis von QUISAM eine Literaturverwaltung. Und siehe da - er brachte sein Programm zunächst nicht ans Laufen, da in QUISAM doch noch zwei kleine Fehler steckten. Diese waren bisher unentdeckt geblieben, da sie nur bei ganz bestimmten Konstellationen auftraten. Aus eigener Erfahrung können wir Ihnen deshalb nur empfehlen, Programme nicht nur selbst ausführlich und eingehend zu testen, sondern sie auch noch einem oder mehreren unvoreingenommenen Dritten zum Test zu geben. Auch bei der Programmierung gibt es das Problem der "Betriebsblindheit", wodurch manchmal sogar gravierende Fehlermöglichkeiten nicht erkannt werden.

Vorsicht ist auch geboten bei nachträglichen Änderungen und Verbesserungen an fertigen Programmen. So manch ausgereiftes, fehlerfreies Programm wurde aufgrund eines neuen Geniestreiches seines Erstellers wieder zur ärgerlichen Fehlerquelle. Klären Sie deshalb vor einer Programmänderung anhand von Dokumentation und Variablenliste sorgfältig ab, auf welche Programmteile diese Änderung alles Einfluß nimmt. Natürlich muß auch jede änderung wieder entsprechend dokumentiert werden. So können Sie dann unliebsame Überraschungen weitgehend vermeiden. Vor steten Änderungen eines von Dritten benutzten Programms sei ohnehin gewarnt. Erheblich sinnvoller ist es, in größeren Zeitabständen komplette Neufassungen Ihres Programms herauszugeben, die dann in ausgetesteter Form alle änderungen enthalten. Auch der Anwender Ihres Programms wird es schätzen, wenn er sich nicht laufend umgewöhnen muß.

Weblinks

• Katalog der Deutschen Nationalbibliothek: 3-89011-007-X