Wie kann man effizienter programmieren?

Übersicht

Sonstiges

Smalltalk

	codehacker Betreff: Wie kann man effizienter programmieren?	Fr, Jun 15, 2012 14:26 Antworten mit Zitat
Hi liebe Coder, ich habe vor einiger Zeit ein Schachprogramm programmiert, funktioniert zwar fehlerhaft, bin aber ganz zufrieden. Was mich stört, ist, daß am Anfang das Coden ganz einfach ging, später aber, als es anfing, komplizierter zu werden, ich immer gründlicher nachdenken mußte, um den "neuen" Codeteil an die richtige Stelle zu implementieren. Es wird immer komplexer und komplexer. Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten. Habt ihr eine Idee? Habt ihr eine Methode, richtig komplexe "Ein-Mann"-Projekte trotzdem erfolgreich über die Bühne zu bringen? Ich meine, ich habe das Schachprogramm ja, soweit ich es haben wollte, aber zum Schluß wurde es so komplex, daß ich eigentlich nicht nochmal auf diese Weise programmieren möchte (2 Tage überlegen, um 20 Zeilen Code korrekt zu schreiben). Bin dankbar für jede Anregung.

codehacker

Betreff: Wie kann man effizienter programmieren?

Fr, Jun 15, 2012 14:26
Antworten mit Zitat

Hi liebe Coder,

ich habe vor einiger Zeit ein Schachprogramm programmiert, funktioniert zwar fehlerhaft, bin aber ganz zufrieden.

Was mich stört, ist, daß am Anfang das Coden ganz einfach ging, später aber, als es anfing, komplizierter zu werden, ich immer gründlicher nachdenken mußte, um den "neuen" Codeteil an die richtige Stelle zu implementieren. Es wird immer komplexer und komplexer.

Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten.

Habt ihr eine Idee? Habt ihr eine Methode, richtig komplexe "Ein-Mann"-Projekte trotzdem erfolgreich über die Bühne zu bringen? Ich meine, ich habe das Schachprogramm ja, soweit ich es haben wollte, aber zum Schluß wurde es so komplex, daß ich eigentlich nicht nochmal auf diese Weise programmieren möchte (2 Tage überlegen, um 20 Zeilen Code korrekt zu schreiben).

Bin dankbar für jede Anregung.

	dont_know_to_use	Fr, Jun 15, 2012 14:35 Antworten mit Zitat
codehacker hat Folgendes geschrieben: funktioniert zwar fehlerhaft, bin aber ganz zufrieden. Was ist dann das Problem, wenn du zufrieden bist? codehacker hat Folgendes geschrieben: Was mich stört, ist, daß am Anfang das Coden ganz einfach ging, später aber, als es anfing, komplizierter zu werden, ich immer gründlicher nachdenken mußte, um den "neuen" Codeteil an die richtige Stelle zu implementieren. Es wird immer komplexer und komplexer. So ist das halt, größere Projekte sind halt komplex. codehacker hat Folgendes geschrieben: Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten. Du musst immer ordentlich programmieren, kommentiere deinen Code, damit du weißt, was du da überhaupt gemacht hast. Ist sinnvoll, wenn du später deinen Code nochmal angucken willst und erst nachdenken müsstet, was du geschrieben hast.

dont_know_to_use

Fr, Jun 15, 2012 14:35
Antworten mit Zitat

codehacker hat Folgendes geschrieben:

funktioniert zwar fehlerhaft, bin aber ganz zufrieden.

Was ist dann das Problem, wenn du zufrieden bist? Wink

codehacker hat Folgendes geschrieben:

Was mich stört, ist, daß am Anfang das Coden ganz einfach ging, später aber, als es anfing, komplizierter zu werden, ich immer gründlicher nachdenken mußte, um den "neuen" Codeteil an die richtige Stelle zu implementieren. Es wird immer komplexer und komplexer.

So ist das halt, größere Projekte sind halt komplex.

codehacker hat Folgendes geschrieben:

Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten.

Du musst immer ordentlich programmieren, kommentiere deinen Code, damit du weißt, was du da überhaupt gemacht hast. Ist sinnvoll, wenn du später deinen Code nochmal angucken willst und erst nachdenken müsstet, was du geschrieben hast.

	Lion Betreff: Re: Wie kann man effizienter programmieren?	Fr, Jun 15, 2012 14:36 Antworten mit Zitat
Hey, unter effizient Programmieren kann man durchaus Verschiedenes verstehen... Aber aufgrund des codehacker hat Folgendes geschrieben: Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten. Vermute ich, dass du meinst, wie man einfach den Überblick behält? Also da gibt's mehrere Dinge, für jeden funktioniert was anderes. Grundsätzlich finde ich es allgemein ziemlich übersichtlich, wenn man möglichst alles objektorientiert programmiert. Die meisten verteilen ihren Code auch auf verschiedene Teile auf, damit es übersichtlich bleibt. Ich mag das überhaupt nicht, da ich dann immer zwischen den ganzen Dateien tabben müsste, wenn ich mal was verändern will. Ich würde das hauptsächlich bei Funktionen machen, an denen ich nichts mehr verändern muss oder bei Konstanten. Alternativ gibts unter effizient noch zu verstehen, dass der Code möglichst schnell läuft, aber das meinst du nicht, oder?^^ Musst du selbst ausprobieren, was für dich klappt
Intel Core 2 Quad 4x2.66 ghz - 4gb ddr2 - nvidia GeForce GTX660 2gb Intel Atom 1x1.83 ghz - 2gb ddr2 - intel GMA 3150 256mb AMD A10-5750M 4x2.5 ghz - 8 gb ddr4 - AMD R9 M290x

Lion

Betreff: Re: Wie kann man effizienter programmieren?

Fr, Jun 15, 2012 14:36
Antworten mit Zitat

Hey,
unter effizient Programmieren kann man durchaus Verschiedenes verstehen... Aber aufgrund des
codehacker hat Folgendes geschrieben:

Es müßte doch eine Möglichkeit geben, egal, wie groß der Code ist/wird, immer gründlich und korrekt zu arbeiten.

Vermute ich, dass du meinst, wie man einfach den Überblick behält?
Also da gibt's mehrere Dinge, für jeden funktioniert was anderes.
Grundsätzlich finde ich es allgemein ziemlich übersichtlich, wenn man möglichst alles objektorientiert programmiert. Die meisten verteilen ihren Code auch auf verschiedene Teile auf, damit es übersichtlich bleibt. Ich mag das überhaupt nicht, da ich dann immer zwischen den ganzen Dateien tabben müsste, wenn ich mal was verändern will. Ich würde das hauptsächlich bei Funktionen machen, an denen ich nichts mehr verändern muss oder bei Konstanten.
Alternativ gibts unter effizient noch zu verstehen, dass der Code möglichst schnell läuft, aber das meinst du nicht, oder?^^
Musst du selbst ausprobieren, was für dich klappt Smile

Intel Core 2 Quad 4x2.66 ghz - 4gb ddr2 - nvidia GeForce GTX660 2gb
Intel Atom 1x1.83 ghz - 2gb ddr2 - intel GMA 3150 256mb
AMD A10-5750M 4x2.5 ghz - 8 gb ddr4 - AMD R9 M290x

	Xeres Moderator	Fr, Jun 15, 2012 15:14 Antworten mit Zitat
Wenn man wirklich einen Plan macht, mit allen Features die es im Spiel geben soll, macht es kaum ein Problem, alles ordentlich um zu setzen. Wenn man mal hier, mal da arbeitet und neue Features implementiert weil man gerade Lust drauf hat, gibt es Codesalat oder man sieht sich gezwungen, den Code öfter mal um zu schreiben. Je früher man sich klar ist, was das Ziel sein soll, desto besser. Beim programmieren anfangen sich zu überlegen, was man eigentlich alles machen will, ist definitiv zu spät. Strukturiert programmieren hilft aber auf jeden Fall. Selbst in BlitzBasic kann man seinen Code noch ganz gut in Funktionen gliedern. Konsistente, aussagekräftige Benennung von Variablen / Konstanten / Funktionen sollte man klar einhalten. Ob man Funktionen / Types in Includes auslagern möchte, hängt von der Größe des Projekts (und der IDE) ab, aber irgendwann kommt man kaum mehr drum herum. Für 20 Zeilen Code 2 Tage: Um die richtige Stelle zu finden, die richtigen Sachen zu tun...? wofür geht dabei die Zeit flöten? Wenn dir die Übersicht fehlt, musst du an der Struktur arbeiten.
Win10 Prof.(x64)/Ubuntu 16.04\|CPU 4x3Ghz (Intel i5-4590S)\|RAM 8 GB\|GeForce GTX 960 Wie man Fragen richtig stellt \|\| "Es geht nicht" \|\| Video-Tutorial: Sinus & Cosinus THERE IS NO FAIR. THERE IS NO JUSTICE. THERE IS JUST ME. (Death, Discworld)

Xeres

Moderator

Fr, Jun 15, 2012 15:14
Antworten mit Zitat

Wenn man wirklich einen Plan macht, mit allen Features die es im Spiel geben soll, macht es kaum ein Problem, alles ordentlich um zu setzen. Wenn man mal hier, mal da arbeitet und neue Features implementiert weil man gerade Lust drauf hat, gibt es Codesalat oder man sieht sich gezwungen, den Code öfter mal um zu schreiben.
Je früher man sich klar ist, was das Ziel sein soll, desto besser. Beim programmieren anfangen sich zu überlegen, was man eigentlich alles machen will, ist definitiv zu spät.
Strukturiert programmieren hilft aber auf jeden Fall. Selbst in BlitzBasic kann man seinen Code noch ganz gut in Funktionen gliedern. Konsistente, aussagekräftige Benennung von Variablen / Konstanten / Funktionen sollte man klar einhalten.
Ob man Funktionen / Types in Includes auslagern möchte, hängt von der Größe des Projekts (und der IDE) ab, aber irgendwann kommt man kaum mehr drum herum.

Für 20 Zeilen Code 2 Tage: Um die richtige Stelle zu finden, die richtigen Sachen zu tun...? wofür geht dabei die Zeit flöten? Wenn dir die Übersicht fehlt, musst du an der Struktur arbeiten.

Win10 Prof.(x64)/Ubuntu 16.04|CPU 4x3Ghz (Intel i5-4590S)|RAM 8 GB|GeForce GTX 960
Wie man Fragen richtig stellt || "Es geht nicht" || Video-Tutorial: Sinus & Cosinus
THERE IS NO FAIR. THERE IS NO JUSTICE. THERE IS JUST ME. (Death, Discworld)

	codehacker	Fr, Jun 15, 2012 15:42 Antworten mit Zitat
Vielen Dank für die Anregungen. Kommentiert habe ich sehr viel. Codesalat hatte ich nicht. Umgeschrieben habe ich kaum etwas. Das Hauptprogramm war nur eine kleine Schleife, alles andere war sauber strukturiert in Funktionen. Variablen waren auch sehr gut bezeichnet. Woran ich als nächstes arbeiten werde: - objektorientiert programmieren lernen (das Programm war prozedural programmiert) - include verwenden Den Überblick hatte ich so gut wie nie verloren. Aber: Der Bruteforce-Algorthmus MiniMax war relativ zügig zu programmieren. Den Alpha-Beta-Cut-Off zu implementieren, der ja eine Optimierung des MiniMax-Verfahrens darstellt, war das, was mich so lange Zeit gekostet hat. 1. Ihn begreifen 2. Ihn nachprogrammieren 3. Ihn im Code an die 'richtige' Stelle implementieren. Daß er mit dem Minimax-Verfahren zusammenarbeitet. Das war knifflig! Aber naja, ich hab's hingekriegt! Trotzdem wünschte ich mir, ich würde in Zukunft nicht mehr soo arg überlegen müssen, um sowas z.B. zu implementieren.

codehacker

Fr, Jun 15, 2012 15:42
Antworten mit Zitat

Vielen Dank für die Anregungen.

Kommentiert habe ich sehr viel.
Codesalat hatte ich nicht.
Umgeschrieben habe ich kaum etwas.
Das Hauptprogramm war nur eine kleine Schleife, alles andere war sauber strukturiert in Funktionen.
Variablen waren auch sehr gut bezeichnet.

Woran ich als nächstes arbeiten werde:
- objektorientiert programmieren lernen (das Programm war prozedural programmiert)
- include verwenden

Den Überblick hatte ich so gut wie nie verloren.

Aber:
Der Bruteforce-Algorthmus MiniMax war relativ zügig zu programmieren.
Den Alpha-Beta-Cut-Off zu implementieren, der ja eine Optimierung des MiniMax-Verfahrens darstellt, war das, was mich so lange Zeit gekostet hat.
1. Ihn begreifen
2. Ihn nachprogrammieren
3. Ihn im Code an die 'richtige' Stelle implementieren. Daß er mit dem Minimax-Verfahren zusammenarbeitet. Das war knifflig!
Aber naja, ich hab's hingekriegt!

Trotzdem wünschte ich mir, ich würde in Zukunft nicht mehr soo arg überlegen müssen, um sowas z.B. zu implementieren.

	Xeres Moderator	Fr, Jun 15, 2012 15:47 Antworten mit Zitat
Das, würde ich sagen, ist normal, wenn man einen Algorithmus schreibt. Neue Konzepte um zu setzen kann seine Zeit dauern - egal ob 5 oder 500 Zeilen Code nötig sind.
Win10 Prof.(x64)/Ubuntu 16.04\|CPU 4x3Ghz (Intel i5-4590S)\|RAM 8 GB\|GeForce GTX 960 Wie man Fragen richtig stellt \|\| "Es geht nicht" \|\| Video-Tutorial: Sinus & Cosinus THERE IS NO FAIR. THERE IS NO JUSTICE. THERE IS JUST ME. (Death, Discworld)

Xeres

Moderator

Fr, Jun 15, 2012 15:47
Antworten mit Zitat

Das, würde ich sagen, ist normal, wenn man einen Algorithmus schreibt. Neue Konzepte um zu setzen kann seine Zeit dauern - egal ob 5 oder 500 Zeilen Code nötig sind.

	Jolinah	Fr, Jun 15, 2012 15:57 Antworten mit Zitat
Edit: Sorry, habe mit schreiben begonnen, bevor du geantwortet hast (Fenster war lange geöffnet) Oft kann man sich ganz leicht eine bessere Übersicht verschaffen indem man darauf achtet keine zu langen Funktionen/Codeblöcke zu schreiben. Teilt man einen langen Code (damit mein ich einen Block/Abschnitt/Funktion) in kleine eigenständige Funktionen auf, so kann man nachträglich jedes Teilproblem in einer übersichtlichen Funktion bearbeiten. Benennt man die Funktionen auch sinnvoll, so weiss man auch später ganz genau, wenn ich bei XYZ was ändern/beeinflussen will, so ist das vermutlich auch in der Funktion die XYZ im Namen enthält etc... Sobald so ein Teil wiederum selber zu komplex wird, teilt man diesen erneut in eigene Funktionen / logische Abschnitte auf. Ansonsten: Viel Code bleibt nunmal viel Code. Da ist es evtl. auch sinnvoll immer bestimmte logische Abschnitte in eine Datei mit entsprechendem Namen ausuzlagern. Oder wenn man schon die Klassen/Types vernünftigt benennt, reicht es auch wenn man jede Klasse/Type in eine einzelne Datei speichert.

Jolinah

Fr, Jun 15, 2012 15:57
Antworten mit Zitat

Edit: Sorry, habe mit schreiben begonnen, bevor du geantwortet hast (Fenster war lange geöffnet) Wink

Oft kann man sich ganz leicht eine bessere Übersicht verschaffen indem man darauf achtet keine zu langen Funktionen/Codeblöcke zu schreiben.

Teilt man einen langen Code (damit mein ich einen Block/Abschnitt/Funktion) in kleine eigenständige Funktionen auf, so kann man nachträglich jedes Teilproblem in einer übersichtlichen Funktion bearbeiten. Benennt man die Funktionen auch sinnvoll, so weiss man auch später ganz genau, wenn ich bei XYZ was ändern/beeinflussen will, so ist das vermutlich auch in der Funktion die XYZ im Namen enthält etc...

Sobald so ein Teil wiederum selber zu komplex wird, teilt man diesen erneut in eigene Funktionen / logische Abschnitte auf.

Ansonsten: Viel Code bleibt nunmal viel Code. Da ist es evtl. auch sinnvoll immer bestimmte logische Abschnitte in eine Datei mit entsprechendem Namen ausuzlagern. Oder wenn man schon die Klassen/Types vernünftigt benennt, reicht es auch wenn man jede Klasse/Type in eine einzelne Datei speichert.

	ToeB	Fr, Jun 15, 2012 19:29 Antworten mit Zitat
Also ich packe meistens möglichst alles in Klassen und Funktionen (Vor allem in BlitzMax hat man ja sehr viele möglichkeiten sein Programm zu strukturieren). Wenn man dann den Funktionen und Klassen vernüftige Namen gibt, dann könnte man selbst nach ein paar Jahren wieder an den Code drangehen und sich fast sofort zurecht finden (ja es stimmt - selbst mal ausprobiert, nachdem ich einen 2 Jahre alten Code auf meiner Externen gefunden habe xD). Das wäre dann so mein Tipp, einfach von Anfang an Gedanken machen, was man alles unter eine Klasse fassen kann und was in eine Funktion kommt. Hinzuzufügen ist noch, das man für jede Klasse am besten eine neue Datei anlegt und dann per "Include" in die Hauptdatei einzubinden, dann hast du bspw. für die Figuren eine Datei "TFigur.bb" und dort ist dann nur die Klasse "TFigur" drin mit ihren dazugehörigen Funktionen. Damit hast du dann das was du suchst in seperaten Dateien und musst nicht immer den ganzen Code durchscrollen Lg, ToeB
Religiöse Kriege sind Streitigkeiten erwachsener Männer darum, wer den besten imaginären Freund hat. Race-Project - Das Rennspiel der etwas anderen Art SimpleUDP3.0 - Neuste Version der Netzwerk-Bibliothek Vielen Dank an dieser Stelle nochmal an Pummelie, welcher mir einen Teil seines VServers für das Betreiben meines Masterservers zur verfügung stellt!

ToeB

Fr, Jun 15, 2012 19:29
Antworten mit Zitat

Also ich packe meistens möglichst alles in Klassen und Funktionen (Vor allem in BlitzMax hat man ja sehr viele möglichkeiten sein Programm zu strukturieren). Wenn man dann den Funktionen und Klassen vernüftige Namen gibt, dann könnte man selbst nach ein paar Jahren wieder an den Code drangehen und sich fast sofort zurecht finden (ja es stimmt - selbst mal ausprobiert, nachdem ich einen 2 Jahre alten Code auf meiner Externen gefunden habe xD).

Das wäre dann so mein Tipp, einfach von Anfang an Gedanken machen, was man alles unter eine Klasse fassen kann und was in eine Funktion kommt. Hinzuzufügen ist noch, das man für jede Klasse am besten eine neue Datei anlegt und dann per "Include" in die Hauptdatei einzubinden, dann hast du bspw. für die Figuren eine Datei "TFigur.bb" und dort ist dann nur die Klasse "TFigur" drin mit ihren dazugehörigen Funktionen. Damit hast du dann das was du suchst in seperaten Dateien und musst nicht immer den ganzen Code durchscrollen Wink

Lg, ToeB

Religiöse Kriege sind Streitigkeiten erwachsener Männer darum, wer den besten imaginären Freund hat.
Race-Project - Das Rennspiel der etwas anderen Art
SimpleUDP3.0 - Neuste Version der Netzwerk-Bibliothek
Vielen Dank an dieser Stelle nochmal an Pummelie, welcher mir einen Teil seines VServers für das Betreiben meines Masterservers zur verfügung stellt!

	ZaP	Fr, Jun 15, 2012 20:05 Antworten mit Zitat
Jolinah hat da schon recht, divide & conquer. Du musst einfach Teilprobleme erkennen und in Funktionen auslagern. Wenn man sich einen komplizierteren Logikblock erdenkt, kann man ja auch schon von Funktionen gebrauch machen, die man noch gar nicht implementiert hat (das tut man im Anschluss). So muss man seine Arbeit an der aktuellen Stelle nicht unterbrechen, und der Block ist weniger Fehleranfällig. Ist jedenfalls meine Vorgehensweise, und sicherlich auch geschmackssache
Starfare: Worklog, Website (download)

ZaP

Fr, Jun 15, 2012 20:05
Antworten mit Zitat

Jolinah hat da schon recht, divide & conquer. Du musst einfach Teilprobleme erkennen und in Funktionen auslagern. Wenn man sich einen komplizierteren Logikblock erdenkt, kann man ja auch schon von Funktionen gebrauch machen, die man noch gar nicht implementiert hat (das tut man im Anschluss). So muss man seine Arbeit an der aktuellen Stelle nicht unterbrechen, und der Block ist weniger Fehleranfällig. Ist jedenfalls meine Vorgehensweise, und sicherlich auch geschmackssache Wink

Starfare: Worklog, Website (download)

	Propellator	Fr, Jun 15, 2012 21:18 Antworten mit Zitat
Im Prinzip gilt das hier: (xkcd.com, guter Webcomic.) Kein Code wird jemals perfekt sein, du wirst immer etwas daran nicht gut finden, mit jeder Design-Entscheidung verzichtest du auf gewisse Eigenschaften wie Flexibilität, Performance oder Simplizität. Was ich gerne tue ist mir ein Notizblatt zu nehmen, und mit einem Bleistift einmal die grobe Funktionsweise des Codes skizzieren. Meistens fallen mir dabei schon Probleme im Konzept auf. Danach baue ich einen kleinen Prototypen, bei welchem dann viele Probleme auffallen. Der funktionsfähige Prototyp wird dann ein ekeliges Stück etwas sein, was nicht mehr gerade dem ursprünglichen Konzept ähnelt. Zu allerletzt kommt das Rewrite, bei welchem ich einfach grosse Teile des Codes neu schreibe und das vorhin gelernte anwende und beachte. Rewrites sind in grossen Projekten (ausgenommen X11, leider) üblich, da sich über die Zeit Altlasten (siehe X11) ansammeln und man an irgend einem Punkt einfach nicht mehr zufrieden mit dem Code und seinen Mängeln ist. Vergiss einfach nie, auch wenns nur für dich selbst ist, den Code zu dokumentieren. So fallen dir eventuell überarbeitungsbedürftige Komponenten schneller auf, da du auch schnell nachschlagen kannst was das Ding überhaupt für einen Nutzen hatte, als du es geschrieben hast.
Propellator - Alles andere ist irrelephant. Elefanten sind die Könige der Antarktis.

Propellator

Fr, Jun 15, 2012 21:18
Antworten mit Zitat

Im Prinzip gilt das hier:

(xkcd.com, guter Webcomic.)

Kein Code wird jemals perfekt sein, du wirst immer etwas daran nicht gut finden, mit jeder Design-Entscheidung verzichtest du auf gewisse Eigenschaften wie Flexibilität, Performance oder Simplizität.

Was ich gerne tue ist mir ein Notizblatt zu nehmen, und mit einem Bleistift einmal die grobe Funktionsweise des Codes skizzieren. Meistens fallen mir dabei schon Probleme im Konzept auf.
Danach baue ich einen kleinen Prototypen, bei welchem dann viele Probleme auffallen. Der funktionsfähige Prototyp wird dann ein ekeliges Stück etwas sein, was nicht mehr gerade dem ursprünglichen Konzept ähnelt.
Zu allerletzt kommt das Rewrite, bei welchem ich einfach grosse Teile des Codes neu schreibe und das vorhin gelernte anwende und beachte.
Rewrites sind in grossen Projekten (ausgenommen X11, leider) üblich, da sich über die Zeit Altlasten (siehe X11) ansammeln und man an irgend einem Punkt einfach nicht mehr zufrieden mit dem Code und seinen Mängeln ist.

Vergiss einfach nie, auch wenns nur für dich selbst ist, den Code zu dokumentieren. So fallen dir eventuell überarbeitungsbedürftige Komponenten schneller auf, da du auch schnell nachschlagen kannst was das Ding überhaupt für einen Nutzen hatte, als du es geschrieben hast.

Propellator - Alles andere ist irrelephant.
Elefanten sind die Könige der Antarktis.

	Lador	So, Jun 17, 2012 13:59 Antworten mit Zitat
Wenn es um "optische" Codeoptimierungen geht, muss man sich einfach selbst ein paar Regeln definieren und diese die ganze Zeit einhalten. Damit meine ich zum Beispiel die Strukturen der Überschriften. Ich mach das etwa so, dass eine große Überschrift (wie "Inventar") in Großbuchstaben schreibe, mehrere Leerzeilen davor und danach lasse, und sie etwas einrücke, sodass sie in der Mitte des Bildschirms steht. Code: [AUSKLAPPEN] [EINKLAPPEN] --------------------------- ----------INVENTAR--------- --------------------------- Die nächsten Überschriften sehen dann etwa so aus: Code: [AUSKLAPPEN] [EINKLAPPEN] SpielerInventar() Handeln() **HaendlerInventar() Es ergibt sich so eine Hierarchie an Überschriften, so wie man es noch von den Hefteinträgen in der Schule kennt. ^^ Einrücken mit Tabulatoren ist auf jedenfall Pflicht, genauso wie mit SuperStrict zu arbeiten (ich benutze BlitzMax). Leerzeilen sind auch sinnvoll und die Code-Datei benötigt dadurch auch nicht viel mehr Speicher, als man vielleicht denken mag. Objektorientiert zu Programmieren ist eigentlich auch ganz schön, aber darüber lässt sich streiten, wie ich finde. Es ist meiner Meinung nach nicht so viel übersichtlicher. Entweder du kennst dich einigermaßen mit deinem Code aus und weißt, wo was steht und was es macht, oder eben nicht. Manche kommen mit massenhaft vielen und langen Kommentaren klar, ich tue es zum Beispiel nicht. Lieber Variablen und Methoden sinnvoll benennen (s. obiges Beispiel ). Letztendlich musst du da aber deinen eigenen Weg finden, vielleicht konnte ich ja mit meiner Erläuterung trotzdem etwas helfen. MFG Lador
Mein aktuelles Projekt: 2D-Rollenspiel "Iliran" Screenshot \| Worklog Fortschritt: ca. 70%

Lador

So, Jun 17, 2012 13:59
Antworten mit Zitat

Wenn es um "optische" Codeoptimierungen geht, muss man sich einfach selbst ein paar Regeln definieren und diese die ganze Zeit einhalten. Damit meine ich zum Beispiel die Strukturen der Überschriften. Ich mach das etwa so, dass eine große Überschrift (wie "Inventar") in Großbuchstaben schreibe, mehrere Leerzeilen davor und danach lasse, und sie etwas einrücke, sodass sie in der Mitte des Bildschirms steht.

Code: [AUSKLAPPEN]

---------------------------
----------INVENTAR---------
---------------------------

Die nächsten Überschriften sehen dann etwa so aus:
Code: [AUSKLAPPEN]

*SpielerInventar()
*Handeln()
**HaendlerInventar()

Es ergibt sich so eine Hierarchie an Überschriften, so wie man es noch von den Hefteinträgen in der Schule kennt. ^^
Einrücken mit Tabulatoren ist auf jedenfall Pflicht, genauso wie mit SuperStrict zu arbeiten (ich benutze BlitzMax). Leerzeilen sind auch sinnvoll und die Code-Datei benötigt dadurch auch nicht viel mehr Speicher, als man vielleicht denken mag.
Objektorientiert zu Programmieren ist eigentlich auch ganz schön, aber darüber lässt sich streiten, wie ich finde. Es ist meiner Meinung nach nicht so viel übersichtlicher. Entweder du kennst dich einigermaßen mit deinem Code aus und weißt, wo was steht und was es macht, oder eben nicht. Manche kommen mit massenhaft vielen und langen Kommentaren klar, ich tue es zum Beispiel nicht. Lieber Variablen und Methoden sinnvoll benennen (s. obiges Beispiel Very Happy

).

Letztendlich musst du da aber deinen eigenen Weg finden, vielleicht konnte ich ja mit meiner Erläuterung trotzdem etwas helfen.

MFG Lador

Mein aktuelles Projekt:
2D-Rollenspiel "Iliran"
Screenshot | Worklog
Fortschritt: ca. 70%

	feider ehemals "Decelion"	So, Jun 17, 2012 15:40 Antworten mit Zitat
Wie kann man effizient schreiben. Mein Tipps/Erfahrungen: 1. Mit einer objektorientierten Sprache (oder teilweise Objektorientiert, so wie C++ und wahrscheinlich auch BlitzMax) _alles_ in Klassen auslagern. Alles. In deiner Hauptfunktion nur Klassenaufrufe starten. Für jeden kleinen Dreck eine eigene Klasse schreiben bzw eigene Funktionen in der Klasse. 2. Wenn die Sprache nicht objektorientiert ist gilt 1. für Funktionen. Mit den Funktionen alles so modular wie möglich aufbauen. Auch wenn es irgendwann übertrieben wirkt, so sehr verlangsamen Funktionsaufrufe das Programm nicht. Vor allem bei Hobbyprojekten in Verbindung mit aktueller Hardware und aktuellen Betriebssystemen sollte dies überhaupt kein Problem darstellen. 3. Dokumentieren und Kommentieren. Modelliere alles was du machst vorher oder hinterher als Flußdiagramm/Klassendiagramm oder in irgend einer anderen Form, die du selbst übersichtlich findest. Macht erstmal Ärger, ist aber auf lange Zeit eine gute Zeitinvestition. Das gleiche gilt für Kommentare, selbst wenn sie übertrieben wirken. Einfach mit ein paar Worten beschreiben, was die Funktion/Klasse macht, was sie für Parameter übergeben bekommt und was sie zurückgibt. 4. Notlösungen als Notlösungen markieren. So verlierst du nicht den Überblick und kannst dir das Ganze nochmal in Ruhe anschauen. 5. Wenn man an einem Problem nicht weiter kommt, erstmal was anderes machen. Entweder was ganz anderes (Zocken, Musik hören, eine Pen&Paper-Runde ins Leben rufen, Handstand üben.) oder sich um die Notlösungen kümmern. Im Hintergrund wirst du dich trotzdem mit dem Problem beschäftigen, von außen hast du dan einen ganz anderen Einstieg in das Problem. 6. Wenn du eine feste Spezifikation hast, was du erreichen willst, können auch Notlösungen eine Möglichkeit sein. Nicht jeder Code muss perfekt modular aufgebaut sein, wenn es den Umfang ins unermessliche steigert, das Programm potentiell die zehnfache Menge an Möglichkeiten bekommt, obwohl diese nie gebraucht werden, ist das auch am Ziel vorbeigeschossen. 7. Punkt 6 wiederspricht Punkt 1 und 2. Insofern einfach an 1 und 2 halten, Punkt 6 kommt automatisch lg Dece

feider

ehemals "Decelion"

So, Jun 17, 2012 15:40
Antworten mit Zitat

Wie kann man effizient schreiben.
Mein Tipps/Erfahrungen:

1. Mit einer objektorientierten Sprache (oder teilweise Objektorientiert, so wie C++ und wahrscheinlich auch BlitzMax) _alles_ in Klassen auslagern. Alles. In deiner Hauptfunktion nur Klassenaufrufe starten. Für jeden kleinen Dreck eine eigene Klasse schreiben bzw eigene Funktionen in der Klasse.

2. Wenn die Sprache nicht objektorientiert ist gilt 1. für Funktionen. Mit den Funktionen alles so modular wie möglich aufbauen. Auch wenn es irgendwann übertrieben wirkt, so sehr verlangsamen Funktionsaufrufe das Programm nicht. Vor allem bei Hobbyprojekten in Verbindung mit aktueller Hardware und aktuellen Betriebssystemen sollte dies überhaupt kein Problem darstellen.

3. Dokumentieren und Kommentieren. Modelliere alles was du machst vorher oder hinterher als Flußdiagramm/Klassendiagramm oder in irgend einer anderen Form, die du selbst übersichtlich findest. Macht erstmal Ärger, ist aber auf lange Zeit eine gute Zeitinvestition. Das gleiche gilt für Kommentare, selbst wenn sie übertrieben wirken. Einfach mit ein paar Worten beschreiben, was die Funktion/Klasse macht, was sie für Parameter übergeben bekommt und was sie zurückgibt.

4. Notlösungen als Notlösungen markieren. So verlierst du nicht den Überblick und kannst dir das Ganze nochmal in Ruhe anschauen.

5. Wenn man an einem Problem nicht weiter kommt, erstmal was anderes machen. Entweder was ganz anderes (Zocken, Musik hören, eine Pen&Paper-Runde ins Leben rufen, Handstand üben.) oder sich um die Notlösungen kümmern. Im Hintergrund wirst du dich trotzdem mit dem Problem beschäftigen, von außen hast du dan einen ganz anderen Einstieg in das Problem.

6. Wenn du eine feste Spezifikation hast, was du erreichen willst, können auch Notlösungen eine Möglichkeit sein. Nicht jeder Code muss perfekt modular aufgebaut sein, wenn es den Umfang ins unermessliche steigert, das Programm potentiell die zehnfache Menge an Möglichkeiten bekommt, obwohl diese nie gebraucht werden, ist das auch am Ziel vorbeigeschossen.

7. Punkt 6 wiederspricht Punkt 1 und 2. Insofern einfach an 1 und 2 halten, Punkt 6 kommt automatisch Wink

lg
Dece

	AnniXa	Di, Jun 19, 2012 9:53 Antworten mit Zitat
Was in meinen Augen auch sehr wichtig sein kann, ist der Einsatz einer Effektiven IDE die einem gefällt und übersichtlich ist. Dies kann enorm helfen die Types in einzelne Dateien zu lagern und diese schnell griffbereit zu haben, (z.B. bei einer IDE mit einer dateiliste so am rand z.B.). Das zusammenklappen von Code (codefolding) ist auch extrem hilfreich, wenn man großere methoden/funktionen die man gerade eh nicht braucht Einfach wegklappen kann. Ein intellipromt kann auch toll sein, vorallem wenn man im tooltip nützliche infos sehen kann wie Parameter oder eine kleine notiz die man an der funktion hat, und bei types/klassen gleich sehen kann was sie so für Methoden/Funktionen und Felder haben. Allein diese kleinen dinge sind sehr hilfreich und zeitsparend. Dazu immer viel kommentieren und vernünftige variablen Namen verwenden aber das war ja schon gesagt. Ansonsten ist es auch gut eine toDo liste anzulegen, bzw sich einen Plan zu machen welche Dinge man schritt für schritt umsetzen möchte. Was ich bei komplexeren dingen oft mache ist den code zu unterteilen in viele kleine schritte und diese zu kommentieren und nach und nach zu schreiben. also in etwa wie (beispiel): 'Schritt 1: Datei öffnen und prüfen ... 'Schritt 2: Byte in den strem ... 'Schritt 3: Datei speichern und schliesen My 2cents
\|moonForge\| Ich bin Pokémon Meisterin seit 1998!

AnniXa

Di, Jun 19, 2012 9:53
Antworten mit Zitat

Was in meinen Augen auch sehr wichtig sein kann, ist der Einsatz einer Effektiven IDE die einem gefällt und übersichtlich ist.
Dies kann enorm helfen die Types in einzelne Dateien zu lagern und diese schnell griffbereit zu haben, (z.B. bei einer IDE mit einer dateiliste so am rand z.B.).
Das zusammenklappen von Code (codefolding) ist auch extrem hilfreich, wenn man großere methoden/funktionen die man gerade eh nicht braucht Einfach wegklappen kann.
Ein intellipromt kann auch toll sein, vorallem wenn man im tooltip nützliche infos sehen kann wie Parameter oder eine kleine notiz die man an der funktion hat, und bei types/klassen gleich sehen kann was sie so für Methoden/Funktionen und Felder haben.

user posted image

Allein diese kleinen dinge sind sehr hilfreich und zeitsparend.
Dazu immer viel kommentieren und vernünftige variablen Namen verwenden aber das war ja schon gesagt.

Ansonsten ist es auch gut eine toDo liste anzulegen, bzw sich einen Plan zu machen welche Dinge man schritt für schritt umsetzen möchte.

Was ich bei komplexeren dingen oft mache ist den code zu unterteilen in viele kleine schritte und diese zu kommentieren und nach und nach zu schreiben.
also in etwa wie (beispiel):
'Schritt 1: Datei öffnen und prüfen
...
'Schritt 2: Byte in den strem
...
'Schritt 3: Datei speichern und schliesen

My 2cents Smile

|moonForge|
Ich bin Pokémon Meisterin seit 1998!