Strukturiertes Programmieren

Hi,

wie kann ich strukturiertes Programmieren lernen?

Bei mir läuft das Programmieren immer nach dem Schema: so ungefähr weiß ich schon was das Prg. nachher alles können soll. Also fange ich halt an zu schreiben. Dann fallen mir noch weitere Dinge ein, die noch angefügt werden. So wird das immer mehr und immer unübersichtlicher. Gravierende Änderungen lassen sich dadurch aber kaum mehr durchführen, weil der zu ändernde Code übers gesamte Prg. verteilt ist. Alles ist sehr speziell gehalten und wenn ich einen ähnlichen Teilcode nochmal verwenden möchte, dann kopiere ich den Teilcode und modifiziere ihn. Dadurch wird das Prg noch länger. Nach einer längeren Testphase fallen mir andere Dinge ein, die noch eingebaut werden müssen. Z.T. lassen sich aber Änderungen wegen der Komplexizität des vorhandenen Prgs gar nicht mehr durchführen. Also müsste man das ganze neu schreiben. Das fällt mir aber erst nach ein paar Wochen ein und in der Zwischenzeit habe wieder viele Tricks und Kniffe vergessen und ich muß mich erst wieder neu einarbeiten. Und was das Schlimmste ist: weil ich alles so konfus programmiert habe, kann ich vom alten Programm nix mehr wiederverwenden!

Vermutlich ist das der gefürchtete Spaghetti-Code.

Meine Fragen: wie gehe ich an ein Projekt ran? Welche Schritte muß ich in welcher Reihenfolge tun?

Gibt’s da was im Internet oder kennt jemand ein gutes Buch? Aber es soll schon für Quereinsteiger sein und leicht verständlich, schließlich bin ich schon über 40! :o)

Martin

PS: Die gleichen Fehler, die ich beim Programmieren mache, habe ich wahrscheinlich auch beim Schreiben dieses Postings gemacht: total konfus. Ob sich da dran noch was ändern läßt? Vielleicht ist das einfach meine Art? Doppelpostings sind ja eigentlich nicht erwünscht, aber ich könnte das ja noch im Psychologieboard probieren… :o)

Hallo.

Das mit dem strukturierten Programmieren ist eigentlich ganz einfach. Vorausgesetzt man verwendet eine Sprache, die ‚Modularisierung‘ erlaubt wie Z.B. C/C++, Java, C#, VB.NET, …
Bei den genannten kann man mehrere Schritte eines Programms in sog. Funktionen zusammenfassen die sich im Programm dann aufrufen lassen.
Hier ein quich’n’dirty Beispiel für C++ (bei Fehlern bitte nicht schimpfen, kann’s grad nicht testen… :wink: )

#include 
void Hallo\_Welt ( cout

Und eine gewisse Selbstdisziplin beim Programmieren muss schon sein. Will sagen, dass man erst eine Funktionalität im Programm zum Laufen bringt. Wenn die läuft kommt die nächste Funktionalität dran usw... Merke: unbehobene Fehlermeldungen von heute sind die Probleme von morgen. Ausserdem ist die optische & funktionale Trennung von Codeblöcken wichtig. Sowie deren Kommentierung damit jeder sieht was der Codeteil tut.

HTH
mfg M.L.

\*\*\*Werbung\*\*\*
http://www.uml.org/
http://www.jeckle.de
http://www.buj.com
http://www.derentwickler.de
http://www.programmersheaven.com

Hi Martin!
Da bist du nicht allein. Wie du gesagt hast, hast du ein paar Ideen im Kopf und fängst dann an zu programmieren. Nach und nach kommen immer mehr Änderungen hier und da und am Ende ist es unübersichtlich und nicht mehr änderbar. So programmieren leider die meisten :frowning:. Um dem entgegenzuwirken, kann du die Methoden der professionellen Softwareentwicklung (in vereinfachter Form) anwenden:

1. Requirements
Bevor du anfängst, drauf los zu tippen, schreibst du dir mal auf ein Blatt Papier, was das Programm können soll (noch nicht wie!), was in Zukunft noch evtl. dazu kommen könnte und so weiter.

2. Design
Nun fängst du immer noch nicht an zu programmieren, sondern überlegst dir, wie du es machst. D.h. welche Programiersprache ist die beste für das Problem, in welche Teile kann man das Programm gliedern und malst dir dann deine Teile als Kringel mit den Beziehungen zwischen diesen Teilen als Linien auf ein Blatt Papier. Wenn du zum Beispiel etwas Verschlüsseln musst in deinem System, füge eine Funktion „Verschlüsselung“ hinzu, überlegt was da für Daten rein kommen (String, Speicherbereich, beides?) und was da wieder raus kommt. Wie du verschlüsselst, ist erst mal egal. Dann ziehst du Linien zu allen Punkten die Verschlüsseln müssen. Vielleicht fällt dir hier auf, dass du auch eine „Entschlüsselung“ brauchst, dass du auch ganze Datei verschlüsseln willst, usw…

3. Implementierung
Beim eigentlichen Programmieren solltest den Quelltext lesbar schreiben (Kommentare!, Einrücken!), solltest sinnvolle Teile gliedern und in einzelne Prozeduren auslagern. Dazu solltest du ein paar Prinzipien beachten, z.B. „Information Hiding“: Mache möglichst die Informationen nur da zugänglich, wo du sie brauchst (Lokale statt globale Variablen). Wenn du eine Funktion aufrufst, dann sollten alle benötigten Werte über die Parameter mitgegeben werden und es sollte für die Nutzung egal sein, wie die Funktion die Werte berechnet. Die Funktion sollte somit auch Seiteneffektfrei sein, d.h. keine globalen Variablen ändern, sondern nur über Eingabe- und Ausgabeparameter Daten ändern. Gleiches gilt auch auf höherer Ebene. Wenn du eine Eingabe, eine Datenbank und eine Datenverwaltung hast, dann sollte die Eingabe niemals direkt die Datenbank benutzen, sondern immer die Funktionen der Verwaltung. Dabei sollte die Datenverwaltung auch nur die Funktionen nach aussen bereitstellen (public/private) die die Eingabe auch wirklich benötigt, alle anderen Funktionen sollten nicht aufrufbar sein. Wenn dann auch noch alle Daten der Eingabe korrekt über Parameter rein kommen, dann ist die Struktur so gut, dass du z.B. die komplette Eingabe durch eine neue ersetze kannst, ohne die Datenverwaltung zu ändern. Dann solltest du zum Beispiel sprechende Variablen- und Funktionenbezeichner wählen. Wem nützt es etwas, wenn der Funktionsname nur vier Buchstaben hat, du aber nicht mehr weisst, was die Funktion void Stgb(a,b) macht. Also schön lang ausschreiben, was gemeint ist. Zu jeder Programmiersprache gibt es heute einen Editor mit Syntaxvervollständigung, also können die Namen auch ruhig 20 Zeichen haben, z.B. in der Form Programmteil_Funktion_Objekt wie „Datenbank_Suche_Vorname“ usw…

Ich könnte so noch Stunden weiterschreiben…

Wichtig ist auf alle Fälle, dass du alle deine Funktionen gut dokumentierst, nimm dir ein Dokumentationstool zur Hilfe, welches dir eine Doku für deinen Quelltext erstellt, z.B. Javadoc(Java) oder Doxygen(C++,VB,…). Dann weisst du auch nachher noch, wofür eine Funktion gut war und kann leichter Änderungen integrieren…

Grüße

Ralph

P.S: Dieser Text ist nicht gut strukturiert :wink:)

Hallo,

Am Anfang sollte immer die Erstellung eines Pflichtenheftes stehen. Dami laesst sich genau festlegen, was in das Programm rein gehoert und was nicht.

Des weiteren gibt es Projektverwaltungstools. Die dann die Dateien fuer dich pflegen, Aenderungen aufzeichen, Dokumentationen entwerfen und so weiter.

All das weiss ich! Und habe es noch nie wirklich benutzt. =:wink:

Mein Code sieht auch immer aus wie Navajo.

It was hard to code, it must be hard to read!

Aber mal im Ernst: wir sollten uns beide mal hinsetzen und nach Woertern wie „Pflichtenheft“ und „Projektplanung“ googeln!

Ciao! Bjoern

Hi Bjoern,

Des weiteren gibt es Projektverwaltungstools. Die dann die
Dateien fuer dich pflegen, Aenderungen aufzeichen,
Dokumentationen entwerfen und so weiter.

Ist sowas für Hobbyprogrammierer erschwinglich? Und gibt’s kein Tool, das auch das Programmieren für mich übernehmen könnte?

Mein Code sieht auch immer aus wie Navajo.

Ohne rassistisch sein zu wollen: sooo schlimm sieht er aus? ;o)

Aber mal im Ernst: wir sollten uns beide mal hinsetzen und
nach Woertern wie „Pflichtenheft“ und „Projektplanung“
googeln!

Vielleicht kugelst besser Du: mein Modem ist recht lahm… Außerdem hören sich diese Ausdrücke schon so trocken und langweilig an - ich glaub’, das ist nix für mich!

Martin

Hi Ralph,

Da bist du nicht allein.

Danke!!! Das geht runter wie Öl!

  1. Requirements
    Bevor du anfängst, drauf los zu tippen, schreibst du dir mal
    auf ein Blatt Papier, was das Programm können soll (noch nicht
    wie!), was in Zukunft noch evtl. dazu kommen könnte und so
    weiter.

Das weiß ich doch in DEM Stadium noch gar nicht! Das ist ja das Problem. Also gut, was die Hauptaufgabe sein soll weiß ich natürlich schon. Aber für detailliertere Überlegungen reicht’s in dem Stadium noch nicht. Außerdem will ich endlich, endlich mit dem Programmieren anfangen!!! (Seufz - das ist wieder was für’s Psychologieboard…)

  1. Design
    Nun fängst du immer noch nicht an zu programmieren, sondern
    überlegst dir, wie du es machst. D.h. welche Programiersprache
    ist die beste für das Problem,

Die Frage stellt sich gar nicht, da ich nur des VBAs mächtig bin bzw. VB.NET gerade lerne.

  1. Implementierung
    Beim eigentlichen Programmieren solltest den Quelltext lesbar
    schreiben (Kommentare!, Einrücken!)

Mach ich eh’.

…solltest sinnvolle Teile
gliedern und in einzelne Prozeduren auslagern.

DA hab ich noch Defizite, das stimmt!

Dazu solltest
du ein paar Prinzipien beachten, z.B. „Information Hiding“:
Mache möglichst die Informationen nur da zugänglich, wo du sie
brauchst (Lokale statt globale Variablen). Wenn du eine
Funktion aufrufst, dann sollten alle benötigten Werte über die
Parameter mitgegeben werden und es sollte für die Nutzung egal
sein, wie die Funktion die Werte berechnet. Die Funktion
sollte somit auch Seiteneffektfrei sein, d.h. keine globalen
Variablen ändern, sondern nur über Eingabe- und
Ausgabeparameter Daten ändern.

Warum das? Was spricht gegen globale Variablen?

Gleiches gilt auch auf höherer
Ebene. Wenn du eine Eingabe, eine Datenbank und eine
Datenverwaltung hast, dann sollte die Eingabe niemals direkt
die Datenbank benutzen, sondern immer die Funktionen der
Verwaltung. Dabei sollte die Datenverwaltung auch nur die
Funktionen nach aussen bereitstellen (public/private) die die
Eingabe auch wirklich benötigt, alle anderen Funktionen
sollten nicht aufrufbar sein. Wenn dann auch noch alle Daten
der Eingabe korrekt über Parameter rein kommen, dann ist die
Struktur so gut, dass du z.B. die komplette Eingabe durch eine
neue ersetze kannst, ohne die Datenverwaltung zu ändern.

Aaaaaahaaa! Toll!

Dann solltest du zum Beispiel sprechende Variablen- und
Funktionenbezeichner wählen. Wem nützt es etwas, wenn der
Funktionsname nur vier Buchstaben hat, du aber nicht mehr
weisst, was die Funktion void Stgb(a,b) macht. Also schön lang
ausschreiben, was gemeint ist. Zu jeder Programmiersprache
gibt es heute einen Editor mit Syntaxvervollständigung, also
können die Namen auch ruhig 20 Zeichen haben, z.B. in der Form
Programmteil_Funktion_Objekt wie „Datenbank_Suche_Vorname“
usw…

Versuch ich auch schon. Aber diese Namen sagen mir nur im Moment was! Ein paar Wochen später frage ich mich dann, wie ich auf diesen schwachsinnigen Namen gekommen bin…
Außerdem denke ich manchmal: so, jetzt probiere ich das mal mit einer Schleife. Und als Schleifenvariable nehme ich dann mal ‚i‘ - iss ja eh’ nur ein Provisorium. Leider wird aus dem Provisorium dann ein Stück endgültiger Code, von dem man froh ist daß er überhaupt läuft. Darum möchte man dann um Himmels Willen nicht den Variablennamen ändern und somit neue Fehler in diesem chaotischen Code erzeugen. Wobei natürlich viele Fehler dann daher kommen, daß der Index wegen einer nachträglich eingefügten zweiten Schleife ‚plötzlich‘ einen anderen Inhalt hat. Ach, das macht Freude… :o))

Ich könnte so noch Stunden weiterschreiben…

Bitte! Tu Dir keinen Zwang an. Ich könnte Dir noch Stunden zulesen…

Wichtig ist auf alle Fälle, dass du alle deine Funktionen gut
dokumentierst, nimm dir ein Dokumentationstool zur Hilfe,
welches dir eine Doku für deinen Quelltext erstellt, z.B.
Javadoc(Java) oder Doxygen(C++,VB,…). Dann weisst du auch
nachher noch, wofür eine Funktion gut war und kann leichter
Änderungen integrieren…

Ja, davon hat Dein Mitbeantworter unten (oder war’s oben? :o) ) auch schon gesprochen. Davon habe ich noch nie gehört. Was bringt mir das? Ich finde, das hört sich eher nach MEHR Arbeit an…

P.S: Dieser Text ist nicht gut strukturiert :wink:)

Ach - einfach nur herrlich… ;o))

Martin

PS:
Ist diese prozedurale Programmierung, die Du so propagierst, nicht eine Vorstufe der OO-Programmierung? Die hat mich bei Excel bzw. VBA schon an meine Grenzen gebracht. Jetzt versuch’ ich das grad unter VB.NET zu checken. Von dem was ich kapier: klingt ja irre. Das verbessert die Struktur eines Programmes ja nochmal erheblich. Wobei mich diese ellenlangen Ausdrücke wie Workbooks(„xyz.xls“).Worksheets(„Tabelle1“).cells(intZeilenindex, intSpaltenindex) am Anfang auch abgeschreckt haben… Oder - eigentlich tun sie das immer noch.

Hi Markus,

Und eine gewisse Selbstdisziplin beim Programmieren muss schon
sein. Will sagen, dass man erst eine Funktionalität im
Programm zum Laufen bringt. Wenn die läuft kommt die nächste
Funktionalität dran usw… Merke: unbehobene Fehlermeldungen
von heute sind die Probleme von morgen.

Das ist auch noch ein guter Tip! Werd’ ich mal probieren…

Martin

Hi,

leider hatte ich heute nicht die Zeit die andern Postings zu lesen. Hole ich morgen nach.

In dem folgenden Buch wird genau beschrieben worauf man achten soltte. Ich fand es als Programmiereinstieger recht verstaendlich. Auch wenn ich jetzt erst mal das ganze in Praxis uebertragen muss um es zu verstehen. Dann werde ich es bestimmt noch ein paarmal lesen :smile:

http://www.derpragmatischeprogrammierer.de/ppbuch/in…

bzw. englische original http://www.pragmaticprogrammer.com/ppbook/index.shtml

polarix, der auch oft unstruckturiert denk und dieses sich auch in Posting niederschlaeg:smile:

Hi,

in dem Buch das ich bereits oben erwaehnt habe gibt es einen guten hinweis.

Mache die Dokumentation zu einem Bestandteil deinen Programmes und somit pflegst du automatisch die Doku wenn du etwas anpassen musst.

Ich habe dieses Prinzip auf meine Arbeit als Netz/Systemadmin uebertragen.
Und bin gerade dabei einiges in ruby zu schreiben.

polarix

Hallo.

wie kann ich strukturiertes Programmieren lernen?

Möglichkeit Eins ist die harte Tour, die Du gerade fährst. Sprich, irgendwann wirst Du Dich so darüber ärgern, den gleichen Sums wieder und wieder und immer wieder neu programmieren zu müssen, dass Du an den Punkt kommst, Dir über Wiederverwendbarkeit Gedanken zu machen (so weit bist Du ja schon fast).

Im Verlaufe vieler Codetippsessionen („Programmieren“ würde ich das, so wie Du es beschreibst, nicht nennen) wird Dir irgendwann eine fröhlich quer durch den Garten hopsende globale Variable einen Schleifenzähler oder Datensatzzeiger so verdrehen, dass Dir die Augen tränen - dann wird sich die Frage nach Kapselung und Variablendeklaration stellen.

Fassest Du möglicherweise einmal mit einem Kumpel zusammen ein größeres Projekt an und dieser „programmiert“ genau so methodisch wie Du, quadrieren sich die obigen Probleme. Du wirst dann auch die drei Todfeinde des Pogrammierers hassen lernen - Sauerstoff, Tageslicht und das unerträgliche Gebrüll der Vögel.

Zusammengefasst heißt das, dass Du Zeit in rauhen Mengen verschwendest, so lange es in Deinen Programmen zugeht wie auf einem codegewordenen Kindergeburtstag.


Möglichkeit Zwo : Wenn Du das nächste Mal ein Projekt angehen willst, schalt den Blechkumpel ab. Zieh Dich mit Bleistift, Zettel, Papier, Kuli, was zu schreiben und einem größeren Vorrat Deiner Lieblingskekse an einen Ort zurück, an dem kein Computer erreichbar ist. Dann schreibe ganz niedertechnologisch auf, was Du eigentlich vorhast, und zwar so, dass Du den Auftrag genau so gut einem Fremden geben könntest, der, außer der deutschen Sprache, gar nichts von Deinem Problem versteht. Also : als wolltest Du einem Doofen erklären, was Du gerade tust …

Du wirst feststellen, dass diese Erklärung Deines Problems auf Papier nur dann funktioniert, wenn Du vorgehst wie beim Klöße- Essen : Eins nach dem anderen, und schön mundgerecht schneiden. Kommst Du beim Verfassen des Textes von der Großmutter auf den Zwetschgenkuchen? Dann wird der „Doofe“ von weiter oben Dein Problem nicht verstehen - return to Start.

Deine Prosa- Problembeschreibung legst Du dann einem guten Freund vor, der möglichst nichts über das Programmieren weiß. Lass Dir von ihm (oder ihr) Deinen Text erklären … klingt wie Choctaw? Siehe vor. Wenn Du Dein Problem einem Menschen nicht verständlich machen kannst, wirst Du es dem Computer auch höchstens andressieren, aber nicht vernünftig beibringen können.

Und warum schrub ich nicht bei Möglichkeit Zwo von der harten Tour? Einfach, weil Dir diese Denkweise ganz viele Umwege ersparen wird. Sie wird Dir recht bald in Fleisch und Blut übergehen - Du wirst ein bärenstarker Analytiker, der bei einem Problem den berühmten Hasen aus dem Pfeffer buchstäblich leuchten sieht. Und dann bist Du auch nicht mehr eine Codekotzmaschine, sondern jemand, der wirklich Software entwickelt.


Wenn Du noch Puste hast, lass uns mal ein Problem gemeinsam angehen. Es sei die Aufgabe, ein Programm zu entwickeln, das den Logarithmus zu einer beliebigen Basis berechnet.

[Ich nehme an, Du weißt z.B.

<sub>2</sub> log 64 = 6, weil 2 ^ 6 = 64 bzw.
<sub>8</sub> log 64 = 2, weil 8 ^ 2 = 64 ...?]

Nun kennt unsere alte Tante VB schon von Haus aus den Logarithmus zur Basis e. DIe Funktion dafür heißt LOG(zahl). Wir wiederum wissen, dass LOG(a)/LOG(b) das Gleiche ist wie der Logarithmus von a zur Basis b. Also programmieren wir fleißig

Public Sub Version1(zahl, basis)
MsgBox Str$((Log(zahl)/Log(basis))
End Sub

und freuen uns über das gelungene Ergebnis. Schade, dass es nichts taugt … welche Macken hat unser Programm? Hier erst denken, dann weiterlesen.


Nun, Version1 ist eine Sub. Diese ist zwar Public, so dass wir sie von überall her aufrufen können - aber das Ergebnis wird nur auf den Bildschirm gekotzt und weiter nix.


Wir machen also eine neue Kiste auf

Public Function Version2(zahl, basis)
Version2=Str$((Log(zahl)/Log(basis))
End Sub

Die Eingabevariablen zahl und basis sind nicht deklariert - wir könnten also versuchen, den Logarithmus von „Murmel“ zur Basis „Grummel“ zu berechnen. Die Funktion würde diese Eingaben annehmen und erst bei der Berechnung aussteigen.


Ncoh n Lied

Public Function Version3(zahl as Double, basis As Double)
Version3=Str$((Log(zahl)/Log(basis))
End Sub

Version3 wird keine anderen Eingaben mehr erlauben als Zahlen. Trotzdem noch keine Zigarre - die Funktion liefert einen String als Ausgabewert, weil wir in Version1 einen String brauchten.


Und spielt der Kandidat weiter …? Schätzungsweise in Version17 wird eine Funktion entstanden sein, die

  • nur definierte Eingaben zulässt,

  • gegen Eingabefehler geschützt ist,

  • eine definierte Ausgabe besitzt,

  • kommentiert ist, damit man auch in 3 Wochen mit ihr noch kraftvoll ins Gras beißen kann,
    >- und so weiter, und so chrysler …

Dabei handelt es sich wirklich nicht um Code, der irgendwelche Tricksereien erfordert : Es werden zwei Zahlen durch eine eingebaute Funktion gejagt und das Ergebnis beider dividiert. Mir sind schon komplexere Dinge untergekommen … Die Überlegungen von oben in einem Rutsch durchgeführt spart Zeit und schont Tastatur und Fingerkuppen.

  • Die Zahl, deren Logarithmus ermittelt werden soll, muss größer 0 sein.

  • Die Basis des Logarithmus muss ungleich 1 und größer 0 sein.

  • Der Ausgabewert ist meist krumm, muss also eine Double- Variable sein.

  • Es dürfen nur Zahlen verarbeitet werden.

  • Wenn wir etwas vergessen haben, soll uns das Programm verraten, was …

  • Einen Default für die Basis anzugeben, wäre auch nicht falsch.

  • […]

und wir erhalten die Funktion

Public Function LogZuBasisX(dblExponent As Double, Optional dblBasis As Double = 10) As Double
If dblExponentDiese Version sollte unsere Anforderungen von oben erfüllen und beliebig einbaubar sein (Einschränkung : getestet ist sie nicht ...).

Du siehst den Unterschied zwischen "Trial and Furor" und einer systematischen Herangehensweise?

Prima.

Gruß kw
  1. Requirements
    Bevor du anfängst, drauf los zu tippen, schreibst du dir mal
    auf ein Blatt Papier, was das Programm können soll (noch nicht
    wie!), was in Zukunft noch evtl. dazu kommen könnte und so
    weiter.

Das weiß ich doch in DEM Stadium noch gar nicht! Das ist ja
das Problem. Also gut, was die Hauptaufgabe sein soll weiß ich
natürlich schon. Aber für detailliertere Überlegungen reicht’s
in dem Stadium noch nicht. Außerdem will ich endlich, endlich
mit dem Programmieren anfangen!!! (Seufz - das ist
wieder was für’s Psychologieboard…)

Das ist ja der Trick an der Sache. Erst überlegen, was man alles braucht, dann erst anfangen. Es muss ja noch nicht alles festgezurrt werden, du solltest dir aber jetzt schon überlegen, was später noch dazu kommen kann, damit du dieses jetzt schon mit in deine Überlegungen einnimmst, auch wenn du es noch nicht programmierst.

Dazu solltest
du ein paar Prinzipien beachten, z.B. „Information Hiding“:
Mache möglichst die Informationen nur da zugänglich, wo du sie
brauchst (Lokale statt globale Variablen). Wenn du eine
Funktion aufrufst, dann sollten alle benötigten Werte über die
Parameter mitgegeben werden und es sollte für die Nutzung egal
sein, wie die Funktion die Werte berechnet. Die Funktion
sollte somit auch Seiteneffektfrei sein, d.h. keine globalen
Variablen ändern, sondern nur über Eingabe- und
Ausgabeparameter Daten ändern.

Warum das? Was spricht gegen globale Variablen?

Gegen globale Variablen spricht, dass man sie überall benutzen und ändern kann und das tut man dann auch und wenn du den Teil dann mal ändern oder erweitern musst, dann musst du den ganzen Quelltext durchsuchen, wo du diese Variable anpackst. Ebenso umgekehrt: Wenn du eine Prozedur hast, in der du globale Variablen liest und änderst, dann hängt das Verhalten dieser Prozedur/Funktion immer von diesen Variablenzuständen ab. Nutzt du aber nur lokale Variablen in der Prozedur und übergibst sonstige benötigten Daten als Parameter, dann hast du eine Funktion, die bei gleicher Eingabe IMMER die gleiche Ausgabe liefert, was die Benutzung dieser Funktion einfacher und übersichtlicher macht.

Dann solltest du zum Beispiel sprechende Variablen- und
Funktionenbezeichner wählen. Wem nützt es etwas, wenn der
Funktionsname nur vier Buchstaben hat, du aber nicht mehr
weisst, was die Funktion void Stgb(a,b) macht. Also schön lang
ausschreiben, was gemeint ist. Zu jeder Programmiersprache
gibt es heute einen Editor mit Syntaxvervollständigung, also
können die Namen auch ruhig 20 Zeichen haben, z.B. in der Form
Programmteil_Funktion_Objekt wie „Datenbank_Suche_Vorname“
usw…

Versuch ich auch schon. Aber diese Namen sagen mir nur im
Moment was! Ein paar Wochen später frage ich mich dann, wie
ich auf diesen schwachsinnigen Namen gekommen bin…
Außerdem denke ich manchmal: so, jetzt probiere ich das mal
mit einer Schleife. Und als Schleifenvariable nehme ich dann
mal ‚i‘ - iss ja eh’ nur ein Provisorium. Leider wird aus dem
Provisorium dann ein Stück endgültiger Code, von dem man froh
ist daß er überhaupt läuft. Darum möchte man dann um Himmels
Willen nicht den Variablennamen ändern und somit neue Fehler
in diesem chaotischen Code erzeugen. Wobei natürlich viele
Fehler dann daher kommen, daß der Index wegen einer
nachträglich eingefügten zweiten Schleife ‚plötzlich‘ einen
anderen Inhalt hat. Ach, das macht Freude… :o))

Also meine Schleifenvariablen heissen auch meisst i oder ii. Dies ist auch in Ordnung, da dann jeder weiss, dass es sich um einen Zähler handelt. Wichtiger sind auf jeden Fall Funktionsnamen und Namen von weiteren Variablen, besonders von globalen.

Wichtig ist auf alle Fälle, dass du alle deine Funktionen gut
dokumentierst, nimm dir ein Dokumentationstool zur Hilfe,
welches dir eine Doku für deinen Quelltext erstellt, z.B.
Javadoc(Java) oder Doxygen(C++,VB,…). Dann weisst du auch
nachher noch, wofür eine Funktion gut war und kann leichter
Änderungen integrieren…

Ja, davon hat Dein Mitbeantworter unten (oder war’s oben? :o)
) auch schon gesprochen. Davon habe ich noch nie gehört. Was
bringt mir das? Ich finde, das hört sich eher nach MEHR Arbeit
an…

Ist es am Anfang auch. Natürlich ist es mehr Arbeit zu einer Funktion noch einen Kommentar hinzuzuschreiben, aber in ein paar Wochen merkst du dann, dass es schon hilft, wenn man viele Kommentare in den Quelltext schreibt. Und so Tools wie Doxygen dienen einfach dazu, sämtliche Funktionen, Prozeduren und Variablen mit den passenden Kommentaren in lesbare/Ausdruckbare Form zu bringen. Wenn du dann ein paar Wochen später einen neuen Teil hinzufügst, dann kannst du in dieser Liste einfach nachschauen, wie die Prozeduren hiessen, die du benutzen musst, welche Parameter ihr übergeben werden und was sie genau macht. Es geht aber auch ohne Tool wie Doxygen, hauptsache, es steht im Quelltext. Beispiel: Eine Funktion, die einen String auf max x Zeichen kürzt:

' Diese Funktion liefert zu einem gegebenen String den gekürzten String der Länge x zurück.
' Ist der String kürzer als x, wird er nicht gekürzt
' Der originalstring wird nicht verändert, es wird nur eine Kopie zurückgegeben
' x muss größer als Null sein
'
function crop\_string(byval originalstr as string, byval maxlen as integer) as string
 crop\_string = left(originalstr,maxlen)
end function 

as reicht schon. Ohne den Quelltext der Funktion zu lesen (der momentan recht kurz ist, aber natürlich viel länger sein kann), siehst du im Kommentar darüber was die Funktion macht und wie sie benutzt werden kann.

PS:
Ist diese prozedurale Programmierung, die Du so propagierst,
nicht eine Vorstufe der OO-Programmierung? Die hat mich bei
Excel bzw. VBA schon an meine Grenzen gebracht. Jetzt versuch’
ich das grad unter VB.NET zu checken. Von dem was ich kapier:
klingt ja irre. Das verbessert die Struktur eines Programmes
ja nochmal erheblich. Wobei mich diese ellenlangen Ausdrücke
wie
Workbooks(„xyz.xls“).Worksheets(„Tabelle1“).cells(intZeilenindex,
intSpaltenindex) am Anfang auch abgeschreckt haben… Oder -
eigentlich tun sie das immer noch.

Nein, Nein. Prozedurale Programmiersprache ist einfach eine Sprache die Prozeduren hat und diese Schachteln kann. VBA ist da eher so ein Zwischending, da VBA Teile von prozeduralen, funktionalen und große Teile von Objektorientierten Sprachen hat (Das Workbook ist nämlich z.B. ein Objekt, auch wenn du es nicht weisst :wink:.

Diese Bandwürmer w(„dsf“).b(„sdf“).c(4).d kannst du mit with abkürzen, also

with w("dsf").b("sdf")
.c(4).d=2
.c(5).d=4
end with

Grüße Ralph