| Autor |
Beitrag |
mexx
      
Beiträge: 1183
|
Verfasst: Do 16.03.06 16:26
Hallo,
viele von euch haben das mit Sicherheit schon oft durchgemacht. Man soll Veränderungen in einem bestehenden Quelltext machen. Dazu ist es aber notwendig, dass man den vorhanden Quelltext zunächst liest, versteht was bezweckt wurde und dann die Fehler findet. Wenn es sich dann auch noch, um ein größeres Programm handelt, welches eine DB-Anwendung darstellt, wird es sehr unangenehm. Wie seht Ihr das, Qual oder eher Easy?
|
|
Jailbird
      
Beiträge: 127
Windows XP Pro SP2
Delphi 7 Professional
|
Verfasst: Do 16.03.06 16:48
Kommt drauf an, a) wie gut der Source kommentiert ist, b) ob das Design z.B. schön OOP ist und durchgezogen wurde oder totaler Hack und c) wie schwerwiegend die "Anpassungen" sind
_________________ Jailbird
|
|
aliB
      
Beiträge: 29
ccux Linux, Windows XP SP2
|
Verfasst: Do 16.03.06 17:52
Es ist sicherlich nicht einfach.
| Joel hat folgendes geschrieben: | | It's harder to read code than to write it. |
Aber bedenke, die Alternative heißt dann -> neu schreiben. Gerade wenn du ein großes Projekt am Wikel hast steckt schon jede Menge knowhow drin.
Ich hab einen schönen Artikel über das Wegwerfen von Code von Joel Spolsky gelesen, hier mal ein Auszug:
| Zitat: | Netscape 6.0 is finally going into its first public beta. There never was a version 5.0. The last major release, version 4.0, was released almost three years ago. Three years is an awfully long time in the Internet world. During this time, Netscape sat by, helplessly, as their market share plummeted.
It's a bit smarmy of me to criticize them for waiting so long between releases. They didn't do it on purpose, now, did they?
Well, yes. They did. They did it by making the single worst strategic mistake that any software company can make:
They decided to rewrite the code from scratch |
Wer den ganzen Artikel lesen möchte: www.joelonsoftware.c...s/fog0000000069.html
Sehr lesenswert!
Moderiert von Christian S.: Quote-Tag repariert
|
|
alzaimar
      
Beiträge: 2889
Erhaltene Danke: 13
W2000, XP
D6E, BDS2006A, DevExpress
|
Verfasst: Do 16.03.06 18:22
Ich bin seit 25 Jahren im Business. Ich habe noch nie eine bestehende SW erweitert oder weiterentwickelt. Auf lange Sicht war es *immer* besser, die Anwendungen neu zu entwickeln. Allerdings waren das nicht solche Monolithen wie Netscape. Und, der bestehende Code war sowieso grauenhaft, schlecht kommentiert und von Inhouse-Mitarbeitern zusammengefrickelt.
Die pauschale Aussage von Joel Spolsky kann ich so nicht unterschreiben. Imho ist es fast immer besser, den vorhandenen Code wegzuschmeissen: Ausnahmen sind natürlich gut dokumentierter Code, aber da stellt sich die Frage nach der Lesbarkeit ('Qual oder Easy') nicht.
_________________ Na denn, dann. Bis dann, denn.
|
|
aliB
      
Beiträge: 29
ccux Linux, Windows XP SP2
|
Verfasst: Do 16.03.06 19:26
| alzaimar hat folgendes geschrieben: | | Auf lange Sicht war es *immer* besser, die Anwendungen neu zu entwickeln. |
Aha, wie konntest du das jetzt beurteilen.
Habt ihr testhalber zwei Teams gebildet, die einen machten alles from scratch die anderen verwendeten den bestehenden code?
Ich finde jedenfalls Joels Argumentation sehr Schlüssig.
1. Die Software funktioniert (deine *neue* tut noch gar nichts!)
2. Bei der Entwicklung wurden viele Fehler mit der Zeit behoben (Fehler die in deiner Applikation mit großer Wahrscheinlichkeit auch vorkommen werden, die du aber erst SUCHEN musst.)
| Joel hat folgendes geschrieben: | Old code has been used. It has been tested. Lots of bugs have been found, and they've been fixed. There's nothing wrong with it. It doesn't acquire bugs just by sitting around on your hard drive....
...
Each of these bugs took weeks of real-world usage before they were found. The programmer might have spent a couple of days reproducing the bug in the lab and fixing it
...
When you throw away code and start from scratch, you are throwing away all that knowledge. All those collected bug fixes. Years of programming work. |
Ich finde er trifft den Nagel auf den Kopf.
|
|
alzaimar
      
Beiträge: 2889
Erhaltene Danke: 13
W2000, XP
D6E, BDS2006A, DevExpress
|
Verfasst: Do 16.03.06 20:51
aliB hat folgendes geschrieben: | | alzaimar hat folgendes geschrieben: | | Auf lange Sicht war es *immer* besser, die Anwendungen neu zu entwickeln. |
Aha, wie konntest du das jetzt beurteilen.
Habt ihr testhalber zwei Teams gebildet, die einen machten alles from scratch die anderen verwendeten den bestehenden code?
|
Deine Argumentation ist unsachlich und nicht sonderlich fundiert, Du kopierst offensichtlich das, was irgendein Joel von sich gibt. Nun denn...
Aber um Dir zu Anworten: Der Erfolg gibt mir Recht. Wir sollten Software erweitern, haben reingeschaut, versucht, den Spaghetticode (gutes altes Basic) zu entwirren, sind gescheitert, bzw. hatten nach einigen Tagen keinen Bock mehr und haben den Müll weggeschmissen und dann neu entwickelt. Die Software läuft noch heute fehlerfrei und ist mehrfach erweitert worden  . Die Entwicklungszeit für die neue Software betrug ca. 6 Monate. Das war erstmal ein Overhead, der sich im Endeffekt (wie immer) ausgezahlt hat.
aliB hat folgendes geschrieben: |
1. Die Software funktioniert (deine *neue* tut noch gar nichts!)
|
Woher kennst Du denn die Software, die wir erweitern sollten? Wo steht geschrieben, das die alte Software funktionierte? Unabhängig davon sollten wir der Software nicht beim Funktionieren zusehen, sondern sie erweitern. Bei unkommentierter und miserabel programmiertem Frickelcode ist es allemal schneller, das Zeugs neu zu entwickeln.
aliB hat folgendes geschrieben: |
2. Bei der Entwicklung wurden viele Fehler mit der Zeit behoben (Fehler die in deiner Applikation mit großer Wahrscheinlichkeit auch vorkommen werden, die du aber erst SUCHEN musst.)
|
'Ali G' wäre ein besserer Nick, denn Du scheinst ein echter Schelm zu sein: Du masst Dir ein Urteil über meine Applikationen an, ohne sie zu kennen. Natürlich entwickelt niemand Code, der von Anfang an perfekt funktioniert, aber ich wiederhole mich: Mit 25 Jahren Erfahrung in der Softwareentwicklung traue ich mir zu, beurteilen zu können, ob es sich lohnt oder nicht. Deinem Profil nach zu urteilen kannst Du das als Azubi (noch) nicht. Also Ball flach(er) halten.
aliB hat folgendes geschrieben: |
| Joel hat folgendes geschrieben: | Old code has been used. It has been tested. Lots of bugs have been found, and they've been fixed. There's nothing wrong with it. It doesn't acquire bugs just by sitting around on your hard drive....
...
Each of these bugs took weeks of real-world usage before they were found. The programmer might have spent a couple of days reproducing the bug in the lab and fixing it
...
When you throw away code and start from scratch, you are throwing away all that knowledge. All those collected bug fixes. Years of programming work. |
Ich finde er trifft den Nagel auf den Kopf. |
Und Ich finde, Du kannst das nicht beurteilen. Unter der Voraussetzung, das sich Deine Erfahrung mit dem Warten existierender Software sehr in Grenzen hält, glaube ich mal, das Du noch nicht all zu oft existierenden Code analysiert hast.
Und in Joel's Argumentation fehlt etwas Entscheidendes: 'When you throw away code and start from scratch, yoa are throwing away all that old fashioned bug fixing, bad code due to overtime, hard to find side effects and design errors'.
Joel geht davon aus, das die existierende Software *gut* war. Im Sinne von wohldokumentiert, robust, korrekt etc.
Ich nicht. Deshalb kann ich seine Erfahrungen nicht nachvollziehen. Er Meine vielleicht auch nicht, keine Ahnung. Er hat mich ja nie gefragt.
_________________ Na denn, dann. Bis dann, denn.
|
|
Robert_G
      
Beiträge: 416
Delphi32 (D2005 PE); Chrome/C# (VS2003 E/A, VS2005)
|
Verfasst: Do 16.03.06 21:17
alzaimar hat folgendes geschrieben: | Joel geht davon aus, das die existierende Software *gut* war. Im Sinne von wohldokumentiert, robust, korrekt etc.
Ich nicht. Deshalb kann ich seine Erfahrungen nicht nachvollziehen. Er Meine vielleicht auch nicht, keine Ahnung. Er hat mich ja nie gefragt. |
Er geht davon aus, dass kein VB monkey den Code runtergerödelt hat sondern ein vernunftbegabter Neuzeitmensch nach bestem Wissen und Gewissen vorgegangen ist.
Nur kann es einfach sein, dass der/die urprünglichen Autoren/du selbst das ganze vor langer Zeit mit längt überholten Herangehensweisen/APIs getan hat.
Wenn die App schwerwiegende/versteckte Bugs hat, bin ich definitiv auf Alzaimars Seite | Zitat: | | Don't fix broken code, dump it |
Wenn nicht, wäre Schritt 1 ein diszipliniertes Refactoring.
Den Code aufräumen, ohne sein Verhaltn zu ändert. Und ganz wichtig ohne Bug fixing.
Mische Refactoring mit Bug fixing und du wirst mit an Sicherheit grenzender Wahrscheinlichkeit den nächsten Bug einschleppen. Nur diesmal ist der zu fixende Code ein Mischmasch aus alten und neuen Herangehensweisen: *brrr*
Also erst den Code entsprechend euren Guidelines refaktorisieren und danach Ändererungen planen.
Martin Fowler Bibel zu Refactoring dürfte eine große Hilfe sein.
|
|
aliB
      
Beiträge: 29
ccux Linux, Windows XP SP2
|
Verfasst: Do 16.03.06 21:33
| Zitat: | | Deine Argumentation ist unsachlich |
Wo war ich unsachlich?
Ich habe lediglich gesagt, das ich Joels Argumentation schlüssiger finde als deine "Argumentation" in der du einfach nur plausibel gesagt hast, dass du aus 25 Jahren Berufserfahrung gelernt hast das "auf lange Sicht es *immer* besser, [ist] die Anwendungen neu zu entwickeln."
Einerseits sagst du das du Joels pauschale Aussage nicht unterstützen kannst und auf der anderen Seite pauschalisierst du selber. Not fair
| Zitat: | | Ali G' wäre ein besserer Nick, denn Du scheinst ein echter Schelm zu sein: Du masst Dir ein Urteil über meine Applikationen an, ohne sie zu kennen |
Ich habe lediglich Joels Argumentation wiedergegeben. -> Keiner (wie du selber zugegeben hast) schreibt perfekten Code. Fehler machen liegt nun mal in der Natur des Menschen. Und zu dem Zeitpunkt an dem du dich entscheidest den Code neu zu schreiben ist es doch exakt so wie ich geschrieben habe. -> Die andere Software ist funktionsfähig, deine besteht zu diesem Zeitpunkt aus 0 Zeilen Code.
| Zitat: | | Mit 25 Jahren Erfahrung in der Softwareentwicklung traue ich mir zu, beurteilen zu können, ob es sich lohnt oder nicht. Deinem Profil nach zu urteilen kannst Du das als Azubi (noch) nicht. Also Ball flach(er) halten. |
Du hast recht, wenn du sagst, das ich (noch) nicht die Erfahrung in Softwareentwicklung habe die du hast, aber ich arbeite daran. Ich war bevor ich Joels Artikel gelesen habe auch deiner Meinung aber seine sachliche Argumentation (und seine lange Berufserfahrung) haben mich überzeugt. Ich find es jetzt aber schade das du gleich Persönlich wirst. Ich habe nichts dagegen, dass du eine andere Auffassung vertrittst.
Halten wir doch mal fest:
Code-Wegschmeiß:
+ Code schreiben ist einfacher als fremden Code lesen. -> Einarbeitungszeit entfällt
+ man schreibt (eventuell) eleganteren Code und eventuell ein bessere Architektur.
Neben der Radikal-Methode gibt es ja auch noch andere Wege wie z.B das Refactoring.
- Man verwendet getesteten Code! Du weißt das Ding läuft.
- es gibt vielleicht sogar so etwas wie Regression Tests die verhindern das bekannte Fehler sich erneut einschleichen. (Was durchaus häufiger vorkommen kann)
- Du kannst es in kleinen Häppchen machen. Während dieser Zeit ist das Produkt Verkaufsfähig, es wird weiter entwickelt (wenn auch nicht in dem Tempo) es werden zusätzliche Bugs gefixt ...
|
|
tommie-lie
      
Beiträge: 4373
Ubuntu 7.10 "Gutsy Gibbon"
|
Verfasst: Do 16.03.06 21:40
mexx hat folgendes geschrieben: | | Wie seht Ihr das, Qual oder eher Easy? |
Ich habe bereits sowohl vollkommen undokumentierten Quellcode manipuliert, als auch sehr ordentlichen und kommentierten Code erweitert. Letzteres war deutlich einfacher, aber es geht beides relativ problemlos, wenn der Code noch überschaubar war (bei mir handelte es sich bei dem undokumentierten Code um wenige tausend Zeilen, vielleicht 2000 oder 3000, keine 80kB C-Code die in lediglich 50kB Binary kompilieren, nichts weltbewegendes also).
Ich kann mir aber durchaus vorstellen, daß bei größeren Projekten die darüber hinaus schlecht dokumentiert und designed sind, das nachträgliche Bearbeiten zur Qual werden kann. Wenn man nicht an OpenSource-Software schreibt, die noch lebt, bearbeitet man tendenziell eher Altlasten als aktuelle Entwicklungen. Diese Altlasten kann man oft auch als solche entsorgen, denn Designs, die man sich früher ausgedacht hat, würde man vielleicht heute vollkommen anders entwickeln. Interessant wird es dann auch noch bei Altlasten-Code von weniger erfahrenen Programmierern. Ich glaube, Code von Azubis, Schülern oder Praktikanten nach Jahren einmal zu erweitern, könnte einer der Kandidaten dafür sein, was ich mal tun werde, wenn ich in die Hölle komme. Bisher bin ich zum Glück davor verschont geblieben.
Meine Herangehensweise an soetwas wäre vermutlich, sich erstmal eine Klasse (bei prozeduraler Programmierung ein Modul) anzuschauen und zu schauen, ob man es selbst ähnlich gemacht hätte oder wenigstens nachvollziehen kann, warum der Programmierer das so gemacht hat. Wenn man das kann, kann man oft auch den restlichen Code nachvollziehen und selber ähnlichen Code zur Codebase beitragen. Scheitert es schon daran, zu verstehen, was dort überhaupt gemacht wird, weil das Design so grottenschlecht ist, weg damit und neu schreiben.
_________________ Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
|
|
tommie-lie
      
Beiträge: 4373
Ubuntu 7.10 "Gutsy Gibbon"
|
Verfasst: Do 16.03.06 21:52
aliB hat folgendes geschrieben: | | Ich habe lediglich gesagt, das ich Joels Argumentation schlüssiger finde als deine "Argumentation" in der du einfach nur plausibel gesagt hast, dass du aus 25 Jahren Berufserfahrung gelernt hast das "auf lange Sicht es *immer* besser, [ist] die Anwendungen neu zu entwickeln." |
Er hat auch gesagt, daß man alte Designs und alte Fehlerbehandlung wegwirft, und nicht nur, wie Joel sagt, vorhandenes Know-How. Wie Robert schon sagte, Joel geht davon aus, daß die ursprüngliche Anwendung sauber ist. Dann steht eigentlich nichts einer nachträglichen Erweiterung im Wege. Dann ist es allerdings auch so, daß der Code so aufgebaut ist, daß eine nachträgliche Erweiterung ohne Mühe machbar ist. Realer Code aus alten Projekten sieht anders aus. alzaimars Argumentation ist hier für mich eindeutig schlüssiger als Joels, denn Joels geht von einem Idealzustand aus, bei dem ich mir gar keine Gedanken machen muss, ob eine nachträgliche Erweiterung möglich oder bequem ist, weil der Code bereits perfekt ist.
| Zitat: | | Ich habe lediglich Joels Argumentation wiedergegeben. -> Keiner (wie du selber zugegeben hast) schreibt perfekten Code. |
Nein, aber man hat früher andere Fehler gemacht als heute und andere Designs verwendet, die für andere Fehler anfälliger waren. Das heute nachzuvollziehen, wenn man an andere Designs gewöhnt ist, die gewisse Fallstricke vermeiden, kann schwierig sein.
| Zitat: | | Die andere Software ist funktionsfähig, deine besteht zu diesem Zeitpunkt aus 0 Zeilen Code. |
Die andere ist aber unzulänglich für ihren neuen Einsatzzweck, sonst würdest du sie nicht erweitern wollen. In einen Trabi baust du auch keinen Formel1-Motor ein. Allein aus Platzgründen.
| Zitat: | | Neben der Radikal-Methode gibt es ja auch noch andere Wege wie z.B das Refactoring. |
Refactoring setzt leider ein gewisses Grundverständnis des vorhandenen Codes voraus, sonst wird auch der refaktorisierte Code ein eigenartiges Wirrwarr.
| Zitat: | | Man verwendet getesteten Code! Du weißt das Ding läuft. |
Du weißt das Ding läuft in seiner gewohnten Umgebung. Nun willst du es erweitern und es somit in ein völlig neues Szenario bringen. Du musst davon ausgehen, daß das Ding erstmal kaputt sein wird und du darfst sämtliche Tests für die neue Umgebung laufen lassen. Erweiterst du ein Warenwirtschaftssystem, indem du ein Webinterface dazustrickst, könntest du es bereits durch die gestiegene Anzahl an Abfragen überlasten, oder auch schon durch die andere Art der Anfragen, weil das Teil nicht dazu gemacht wurde, daß jetzt auch noch die Kunden per Browser drauf zugreifen und sich ihren aktuellen Abwicklungsstatus alle fünf Minuten anzeigen lassen wollen.
| Zitat: | | es gibt vielleicht sogar so etwas wie Regression Tests die verhindern das bekannte Fehler sich erneut einschleichen. (Was durchaus häufiger vorkommen kann) |
Wenn du die alten Test-Funktionen nicht mehr hast, darfst du dir diese Tests auch noch selber schreiben.
_________________ Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
|
|
aliB
      
Beiträge: 29
ccux Linux, Windows XP SP2
|
Verfasst: Do 16.03.06 22:08
| Zitat: | | Er hat auch gesagt, daß man alte Designs und alte Fehlerbehandlung weg wirft, und nicht nur, wie Joel sagt, vorhandenes Know-How. |
Nicht im ersten Post! Im ersten Post sagt er nur das was ich zitiert habe. Aber egal. Ich nehme sein Argument zur Kenntnis und sehe ein, dass es durch aus eine Berechtigung hat.
| Zitat: | | Joel geht davon aus, daß die ursprüngliche Anwendung sauber ist ... Joels geht von einem Idealzustand aus, bei dem ich mir gar keine Gedanken machen muss, ob eine nachträgliche Erweiterung möglich oder bequem ist, weil der Code bereits perfekt ist. |
Hab ich so nicht rauslesen können. Zitat? Wo schreibt er denn sowas?
Mag sein das mein englisch nicht so prikelnd ist aber so wie ich ihn verstehe geht er sogar ausdrücklich davon aus das der Code wirklich schlecht ist. Aber selbst dann (so Joel) gibt es noch andere Möglichkeiten als Tabula rasa zu machen. Gerade der letzten Absatz behandeln diese Thematik.
| Joel hat folgendes geschrieben: | | When programmers say that their code is a holy mess (as they always do), there are three kinds of things that are wrong with it... |
|
|
aliB
      
Beiträge: 29
ccux Linux, Windows XP SP2
|
Verfasst: Do 16.03.06 22:23
|
|
tommie-lie
      
Beiträge: 4373
Ubuntu 7.10 "Gutsy Gibbon"
|
Verfasst: Do 16.03.06 22:50
aliB hat folgendes geschrieben: | | Zitat: | | Joel geht davon aus, daß die ursprüngliche Anwendung sauber ist ... Joels geht von einem Idealzustand aus, bei dem ich mir gar keine Gedanken machen muss, ob eine nachträgliche Erweiterung möglich oder bequem ist, weil der Code bereits perfekt ist. | Hab ich so nicht rauslesen können. Zitat? Wo schreibt er denn sowas? |
| Zitat: | As a corollary of this axiom, you can ask almost any programmer today about the code they are working on. "It's a big hairy mess," they will tell you. "I'd like nothing better than to throw it out and start over."
Why is it a mess?
"Well," they say, "look at this function. It is two pages long! None of this stuff belongs in there! I don't know what half of these API calls are for." |
Ein Programmierer, der mir sagt, er habe Code geschrieben, von dem er die Hälfte nicht versteht, ist eigenwillig. Ich kann mir nur zwei Möglichkeiten vorstellen, wie ein Programmierer Code erzeugt, dessen Semantik er selbst nicht kapiert: Copy&Paste aus anderen Quellen ohne den Code nachzuvollziehen oder Trial&Error bis es geht. Beides sind Verfahren, die alles andere als professionell sind und die mich daran zweifeln lassen, daß der Rest des Codes besser ist. Und wenn der gesamte Code per Trial&Error erschlossen wurde, ist er weder stabil noch sicher, dann ist er einfach, was er ist: ein Kartenhaus, das so lange funktioniert, solange man lediglich das tut, was der Programmierer versucht hat und bei dem es keinen Fehler gab. Sobald man einen anderen Versuch nimmt, der zum Fehler führt, fällt das Haus zusammen.
| Zitat: | | The idea that new code is better than old is patently absurd. Old code has been used. It has been tested. Lots of bugs have been found, and they've been fixed. There's nothing wrong with it. |
Dann soll er mir sagen, warum die Leute überhaupt auf die Idee kommen, ihn neu zu schreiben, wenn nichts damit los ist.
| Zitat: | | One of them fixes that bug that Nancy had when she tried to install the thing on a computer that didn't have Internet Explorer. Another one fixes that bug that occurs in low memory conditions. Another one fixes that bug that occurred when the file is on a floppy disk and the user yanks out the disk in the middle. That LoadLibrary call is ugly but it makes the code work on old versions of Windows 95. |
Die Bugs, die er anspricht, indizieren schlechtes Design und Code-Redundanz. Wenn ich die Fehlerbehandlung für knappen Arbeitsspeicher in eine Funktion inline, die überhaupt nichts damit zu tun hat, bedeutet das, daß die Funktion offensichtlich etwas vollkommen anderes machen sollte, zum Beispiel einen Datei lesen oder schreiben. Allerdings ist das nicht der einzige Ort, an dem Speicher allokiert wird. Das wiederum bedeutet, ich brauche den Fix, der bei knappen Speicher greift, nicht nur in der Funktion, die eine Datei lädt, sondern an allen dreimillionenvierhundertzweiungsechzigtausendsiebenhunderteinundvierzig anderen Stellen, die Speicher allokieren. Der Fix müsste an all diesen Stellen auftauchen, und vergesse ich eine, taugt er schon nichts mehr. Schlimmer noch, wenn ich eine Lücke im Fix entdecke darf ich diese Stellen alle abgrasen und den Fix für den Fix einbauen. Bestehende Fixes hin oder her, aber das, was Joel da beschreibt, ist einfach *mist*e.
| Zitat: | | there is absolutely no reason to believe that you are going to do a better job than you did the first time. |
Hier geht er sogar davon aus, daß tatsächlich derjenige, der den ersten Code geschrieben hat, ihn also am besten verstehen sollte, den neuen schreiben will. Hätte ich es besser gewusst, hätte ich es von Anfang an richtig gemacht. Selbst durch gewachsenen Code blickt man selbst noch durch, aber niemals jemand anderes. Und das ist das Problem, Joel geht nicht darauf ein, daß *andere* den Code lesen wollen.
(aus seinem ersten Punkt der Gründe, warum Programmierer sagen der Code sei schlecht) | Zitat: | | They can be done by one programmer working carefully and checking in his changes all at once, so that nobody else is disrupted. |
Und was sollen die anderen dabei machen? Am alten Code weiterarbeiten und die alten Funktionen an ihren alten Orten in ihren alten Namespaces aus den alten Klassen heraus mit den alten Parametern aufrufen? Klasse Idee. Wann wird derjenige fertig sein, der diese Refaktorisierungsaufgabe übernehmen soll? Zwei Monate nach dem Release, wenn der Code lange genug frozen ist?
Außerdem reitet er mit allgemein zu sehr auf dem Netscape-Beispiel rum. Netscape hat nicht einfach gesagt, sie wollen den Code neu schreiben. Netscape hatte bereits vorher Boden an Microsoft abtreten müssen und sie sind mit ihrer 4er-Version vom Communicator sowohl technisch als auch von der Stabilität her ständig ein wenig hinterhergestolpert. Mit einem Bugfix nach dem anderen (8 in einem Jahr). Es war offensichtlich, daß sie mir ihrem eigenen Quellcode nicht mehr zurechtgekommen sind. Ja, Joel hat Recht, sie wollten ihren alten Code wegwerfen und neuen schreiben. Aber nicht, weil sie ihn hässlich fanden, sondern weil sie einfach nicht mehr mit klar gekommen sind. Sie waren nicht mehr in der Lage, schnell stabile Software zu produzieren. Und sie haben damit angefangen, als sie den Browserkrieg bereits verloren hatten. Die ganze Geschichte hat Netscape deutlichst weniger Marktanteile gekostet als Joel es in seiner Einleitung darstellt. Außerdem hat NEtscape nicht drei Jahre däumchendrehend daneben gesessen, wie Joel ebenfalls glauben machen will. Netscape wurde ziemlich zeitnah von AOL aufgekauft und es ist wohl eher AOLs halbherzigem Engagement zu verdanken, daß es erst Jahre später eine nächste Netscape-Version gab, denn die Mozilla-Suite war schon früher einsetzbar.
Netscapes Beispiel lässt sich in der Tat genau zur entgegengesetzten Argumentation nutzen als Joel es tut. Der Communicator war gewachsene Software. Sie war instabil und technisch unterlegen. Es dauerte lange, um neue Features zu implementieren und es war aufwändig. Stabilität hat Netscape nie vollständig in den Griff gekriegt. Und sie haben es mehrere Versionen lang versucht. Stattdessen haben sie den Code freigegeben (ebenfalls etwas, was Joel verschweigt, Netscape war nämlich nicht mehr maßgeblich an der Entwicklung beteiligt) und von der OpenSource-Community neu schreiben lassen. Was wir jetzt haben ist eine zuverlässige und sehr bequem und schnell erweiterbare Browser-Suite (die Rede ist vom SeaMonkey, nicht vom Firefox), die dem Communicator in so ziemlich allen Dingen überlegen ist, es hat sich also gelohnt, den Code neu zu schreiben.
_________________ Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
|
|
Klabautermann
      

Beiträge: 6366
Erhaltene Danke: 60
Windows 7, Ubuntu
Delphi 7 Prof.
|
Verfasst: Fr 17.03.06 08:00
Hi,
ich habe während des Studiums mal gelernt, dass man Softwere, die man selbst geschrieben hat, nach der Fertig stellung weg schmeißen soll und es noch mal machen. Denn bei der Fertig stellung hat man so viel gelernt (in der Regel währnd man es anders [weniger gut] umgesetzt hat) dass der zweit Anlauf wesendlich höheren Qualitätsansprüchen genügt.
Wenn man ein bestehendes Projekt übernimmt, ist also die Frge hat der vorherige Programmierer im laufe seiner Projektarbeitszeit mehr know how erworborben und umgesetzt als man selber mitbringt. Denn wenn das so ist wird das eigene, neu geschriebene, Programm zwar für einen selber Verständlicher aber qualitativ nicht besser sein als die alte Version.
Ich persönlich habe schon einige Projekte übernommen, teilweise wahren diese auch sehr groß und es gabe keines an dem ich nciht einiges auszusetzen gehabt hätte, aber bei ca. 50% der Dinge die ich anfangs schrecktich unlogisch fand musste ich nach einer weile fest stellen, dass es so für diesen Fall eine hervorragende Lösung war.
Da alle diese Projekte recht gut modularisiert wahren (wenigstens von funktionen hatte jeder meiner vorgänger mal gehört und sie über mehrere Dateien verteilt  ) war es noch nie nötig etwas komplett neu zu schreiben, was aber Fast immer nötig war ist einzelne (teils sehr zehtrsle) Funktionsbereiche komplett neu zu schreiben. Welche das sind kann man aber, wenn sie nicht von Anfang an offensichtlich fehlerhaft laufen, erst sagen wenn man in dem Projekt dirn steckt, also schon eine Weile an ihm gearbeitet hat.
Man muss also nicht zwangsweise alles ersetzen, wenn nur ein teil schlecht ist und man kann in der Regel erst spät entscheiden was schlecht ist.
Das schon diese Entscheidung ist die übernahme eines Projektes selten wirklich "easy" aber es gehört auch zu unserem Job sich in die Denke eines anderen rein zu finden und diese dann durch die eigene zu berreichern. Spätestens wenn man mit mehreren an einem Projekt arbeitet wird das ohnehin unumgänglich.
Gruß
Klabautermann
|
|
BenBE
      
Beiträge: 8721
Erhaltene Danke: 191
Win95, Win98SE, Win2K, WinXP
D1S, D3S, D4S, D5E, D6E, D7E, D9PE, D10E, D12P, DXEP, L0.9\FPC2.0
|
Verfasst: Fr 17.03.06 11:52
In den meisten Fällen finde ich solche Anpassungen eigentlich relativ easy ... Wie Jailbird schon richtig sagte, hängt das auch stark vom vorliegenden Quelltext ab. Weiterhin sollte man aber auch noch erwähnen, dass ein weiterer Faktor zu beachten ist: Wie sehr man in die Thematik eingearbeitet ist. Ich werd also wohl kaum ein Wahrenwirtschaftssystem anpassen (oder mich dazu zur Vefügung stellen), wenn ich bisher nur Game Engines programmiert hab.
_________________ Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.
|
|
|