Hallo!

Ich arbeite jetzt seit einigen Wochen mit Delphi und hab (in meinen Augen) erstaunlich große Fortschritte gemacht (Delphi halt ).
Zu einem Thema krieg ich aber trotz Buch lesen und Forum-Stöbern keinen runden Überblick:

Was kann ich wirklich grundlegend falsch machen oder vergessen und damit wirklich schwerwiegende Probleme beim Anwender verursachen?

Halt, jetzt keine Panik, ich weiß, daß die Frage viel zu allgemein ist und so nicht beantwortet werden kann. Ich versuchs mal einzugrenzen:

Also ich meine nicht Endlosschleifen oder fehlende Exeptionbehandlung, das sind für mich "logische" Probleme die ja auch während der Entwicklung und beim Testen bei mir selbst auftreten.
Ich lese aber oft z.B. von "Objekt freigeben" (dabei gehts doch immer um Speicher, oder?); gerade beim Thema "Exceptions" stößt man oft auf "finally", damit das und das unbedingt freigegeben wird. Ich hab hier im Forum einen ganz guten Thread zu dem Thema gefunden, aber was gibt es da sonst noch?

Da ich mich auch ein bißchen mit Webdesign beschäftige, hab ich Erfahrung damit, daß am Ende alles am Anwender hängt (welche Plattform, Auflösung, Farbtiefe, Fenstergröße, Browser, etc.) obs halbwegs gut aussieht. Irgendwie kann ich mir nicht vorstellen, daß das bei Programmen anders sein soll (na, wie *mist*e mein super designtes Programm bei 800x600, große Schriftarten und 256 Farben plötzlich aussieht, musste ich ja schon leidvoll feststellen ). Eine Website, die einfach nicht schön aussieht ist aber was anderes, als ein Programm, daß nicht richtig funktioniert oder vielleicht noch andere Probleme verursacht.

Mir würde es erst mal völlig ausreichen, wenn mir jemand Absolution erteilt, indem er mir folgendes bestätigt:

Gehe ich recht in der Annahme (jo, Willkommen bei "Was bin ich", welches Schweinderl... ), daß, wenn ich ein Formular mit den Standard-Komponenten bestücke, deren Eigenschaften und Ereignisse zur Entwicklung oder Laufzeit ändere, "Standard-Variablen" (String, Real, Int) benutze, usw., ich mir keine großen Sorgen machen muss, daß mein Programm Windows zerschießt oder wie ein vollgekiffter Hausbesetzer den Arbeitsspeicher bis zum nächsten Neustart belagert? (Langer Satz, ich weiß, sorry).

Ich meine, wenn ich anfange, an der Registry rumzufummeln, direkt auf Hardware zugreifen will, oder auf die Windows API , daß ich da schon eingiges falsch machen kann, finde ich logisch (Gottseidank kann ich sowas nicht (noch... )).Aber wo ist die Grenze?

Hintergrund des ganzen ist eigentlich: Ich hab jetzt ein Preis-/Angebots-Programm für unsere Außendienstler geschrieben. Das funktioniert gut genug, um es jetzt einzusetzten. Allerdings wird dieses Programm nur auf völlig identischen Notebooks laufen, und da ich auf denen schon getestet habe, gehe ich kein Risiko ein. Jetzt will ich für unsere Kunden auch ein Preisabfrage-Programm mit Bestellfunktion machen. Ich weiß, daß ich das Programm so hinkriege, wie ich es mir vorstelle, aber das wird dann an einige hundert Kunden verteilt, teilweise mit den unmöglichgsten PC-Konfigurationen. Und da bin ich mir dann nicht mehr so sicher...
(ich mach mir schon genug Sorgen darüber, daß der Programm-Ablauf Fehler haben könnte, die ich nicht bedacht habe, schließlich verläßt sich der Anwender ja auf die Werte, die ein Programm ausgibt).

Man kann es allerdings auchübertreiben, oder? Bei so kleinen Anwendungen, wie ich Sie erst mal vorhabe. Ich denk dann immer an die Profis, die richtig große, umfangreiche Programme schreiben, sind ja auch nur Menschen und tragen trotzdem diese Verantwortung.
Auf der anderen Seite will ich aber auch nicht aus falscher Unbescheidenheit direkt was verteilen, um später festzustellen, daß ich noch nicht so weit bin.

Ich hoffe, irgendjemand hat verstanden, um was es mir geht (hab wenig Hoffung, weil ich mich hier abquäle das zu beschreiben und so ne elende Laber-Tasche bin ). Ich weiß einfach nicht genau, was ich neben einem funktionierenden Programmablauf noch beachten muss.

Auf jeden Fall schon mal vielen Danke, daß Du bis hierhin gelesen hast, für jede Antwort spring ich dann auch extra einmal vom Stuhl auf...

Gruße, Bruce

Hi,

also, Du als Programmierer kannst niemals alle Fehler in einem Programm was Du programmiert hast finden. Das tue ich auch nicht. Es ist klar, das Du die Fehler berenigst, die Dir der Compiler vor gibt oder die Du beim Testen der Funktion bekommst (Exception etc.). Deshalb ein Tip von mir, suche Dir ein paar Feldtester und die testen halt Dein Programm auf Herz und Nieren. Die sollen Dir aufschreiben, was Sie gemacht habe und welcher Fehler dann aufgetreten ist. Damit kannst Du eventuelle Fehler besser nachvollziehen.
Dieses ist nur ein Beipsiel, es kommt immer auf die größe des Programms an und auf das was es kann :

Meinetwegen Du machst einen Test über 2 Wochen, Du sammelst alle Fehler. Danach setzt Du Dich hin und versuchst die Fehler nachzuvollziehen und die zu beheben. Danach machst Du noch mal einen Test über 1 Woche, wo die Testuser nochmal speziell auf die ersten Fehler eingehen. Das wiederholst Du so lange bis die Testgruppe sagt, wir haben nichts gefunden. Dann gibst Du erst Dein OK, dass jetzt das Programm verteilt werden darf.

Zitat:

Gehe ich recht in der Annahme (jo, Willkommen bei "Was bin ich", welches Schweinderl... icon_smile.gif), daß, wenn ich ein Formular mit den Standard-Komponenten bestücke, deren Eigenschaften und Ereignisse zur Entwicklung oder Laufzeit ändere, "Standard-Variablen" (String, Real, Int) benutze, usw., ich mir keine großen Sorgen machen muss, daß mein Programm Windows zerschießt oder wie ein vollgekiffter Hausbesetzer den Arbeitsspeicher bis zum nächsten Neustart belagert?

Also: Komponenten, die Du in der IDE zur Erstellungszeit plazierst, musst Du nicht wieder freigeben. Das macht Delphi für Dich.
Bei Variablen, die Du zur Laufzeit verwendest, kann man die Grundregel benutzen: alles, was Du mit Create erzeugst, musst Du hinterher mit Free wieder entfernen.
Meines Wissens wird beim Programmende zwar der Speicher wieder freigegeben (es gab mal einen Thread hier, indem darüber diskutiert wurde, aber ich bin nicht mehr auf dem laufenden), aber es ist einfach guter Stil, das selbst zu machen.
Um die Regel von oben noch etwas mit Inhalt zu füllen (ansatzweise): Du musst zwischen "primitiven Datentypen" und "Referenzdatentypen" unterscheiden.
Zu den primitiven Datentypen gehören: Boolean, die ganzen Integer-Datentypen, die Float-Datentypen, String und Char. Habe ich was vergessen? Mir ist so, aber mir fällt's nicht ein. Bei denen musst Du Dich um die Speicherveraltung nicht kümmern. (Übrigens: Vorsicht! String ist nicht in allen Programmiersprachen ein primitiver Datentyp und z.B. in Java gibt es auch einen Referenzdatentyp Integer!)
Bei Referenzdatentypen musst Du zwischen Objekten und Referenzen auf Objekte unterscheiden. Wenn Du eine Deklaration machst wie "VAR my_object : TMy_object;" dann ist das erstmal kein Objekt, sondern eine (erstmal leere) Referenz. Erst mit dem "Create" erzeugst Du ein neues Objekt, welches Speicher belegt. Bei primitiven Datentypen ist jede deklarierte Variable sofort auch eine "eigenständige" Variable.

Ach ja, ich setze in meine Programme (die ich allerdings auch nicht beruflich schreibe, sondern nur so für Freunde und bekannte oder das liebe, liebe Internet) immer die Klausel, dass der Autor für etwaige Folgen, die aus der Nutzung des Programmes resultieren, nicht verantwortlich gemacht werden kann. Und das die Korrektheit von Ergebnissen nicht garantiert werden kann.