Follow my new blog

Dienstag, 1. Februar 2011

Mehr vom Selben hilft nicht mehr

Martin Fowlers Vortrag hat mich leider enttäuscht. Heute abend hätte er über “Software Design in the 21st Century” sprechen sollen. Gesprochen hat er aber stattdessen in drei “Minivorträgen” über DSLs – anlässlich seines gerade erschienenen Buches zum Thema –, REST und die Agilitätsbewegung am Ende der ersten 10 Jahre. Das war alles wenig inspirierend und wenig inspiriert, fand ich.

Nun frage ich mich aber, warum hat er nicht das ursprüngliche Thema behandelt? Sicher war nicht nur ich im ausverkauften Saal auf seine Sichtweise gespannt. Meine Vermutung – mal so ganz keck geäußert: Er hat dazu auch keine rechte Idee.

Die Branche mokelt halt so vor sich hin. SOA ist entweder tot oder hat sich still ins Pragmatische zurückgezogen. Funktionale Programmierung rettet im Verbund mit Multi-Core Prozessoren auch nicht kurzfristig die Softwarewelt. Um XP ist es sehr still geworden; funktioniert also entweder einfach oder wird so lange adaptiert, bis davon nichts mehr übrig ist. Scrum verliert sich in Lagerfehden. Und sonst so?

Tja… das große Problem wartbarer Software, d.h. flexibler, evolvierbarer, langlebiger und auch noch möglichst fehlerfreier Software, die im Rahmen gegebener Ressourcen entwickelt wird, das Problem ist schlicht ungelöst. Und eine Lösung ist nicht in Sicht.

Nicht, dass ich eine Silberkugel im Samtkästchen von Martin Fowler erwartet hätte. Aber mit DSLs, REST und ein bisschen Geschichten erzählen unter dem Titel “Software Design in the 21st Century" aufzutreten, finde ich schwach.

So einfach vergessen kann ich den Abend aber nicht. Denn da ist etwas, das Martin Fowler eher nur am Rande gesagt hat, das mich wurmt. Er hat nämlich gesagt, wir stünden bei der Agilität noch am Anfang. Warum? Weil wir selbst bei der Objektorientierung nach 40 Jahren noch nicht am Ziel seien. Die Agilität solle sich also besser darauf einstellen, auch noch ein paar Jahre zu brauchen.

Einerseits ist da sicherlich wahr: Entwicklungen brauchen ihre Zeit, selbst wenn sie in die richtige Richtung gehen. Und da die Agilität nicht nur mit Technologie zu tun hat, sind ihre Auswirkungen weitreichender als bei der Objektorientierung. Mehr Menschen müssen sich anpassen. Also dauert es auch lange oder gar länger.

Aber andererseits… Wir reden hier ja nicht über Naturgesetze oder den menschlichen Körper. Da mag es Jahrhunderte dauern, bis wir die wahren Zusammenhänge erkennen. Wir reden über menschengemachte Konzepte und Werkzeuge. Und da erlaube ich mir die Frage: Wenn etwas Menschengemachtes nach Jahrzehnten immer noch Schwierigkeiten bereitet, ist das dann ein Problem der Leute, die damit immer noch und immer wieder Schwierigkeiten haben? Oder ist das ein Problem von Konzept bzw. Werkzeug?

Die Natur lässt sich nicht ändern, ob wir sie verstehen oder nicht. Bei der Softwareentwicklung habe ich da aber einen anderen Anspruch.

Fowler, Beck, Martin et al. werden nicht müde hervorzuheben, dass die allermeisten Entwickler die Objektorientierung nicht wirklich verstanden hätten. Es würde eher mit OO-Sprachen immer noch prozedural programmiert.

Das mag sein – aber wessen Problem ist das denn? Warum erhebt sich nicht laut und breit die Frage, ob denn Objektorientierung in der scheinbar nur sehr, sehr, sehr schwer zu vermittelnden “richtigen” Weise überhaupt erstrebenswert ist? Wenn Millionen von Entwicklern über Jahrzehnte es nicht hinkriegen, dann können wir – so glaube ich – ausschließen, dass die Millionen zu doof sind. Oder wenn, dann ist das eben so. Auch egal. In jedem Fall muss dann die Methode, das Paradigma überprüft werden.

In der Finanzwelt gilt: “Nicht realisierte Gewinne sind keine Gewinne.” Das sollten wir auf die Softwareentwicklung übertragen: “Erfolgversprechende Ansätze, die jahrzehntelang hinter den Erwartungen zurückbleiben, sind überbewertet.”

Wenn die Objektorientierung nach 40 Jahren die Softwareentwicklung nicht deutlich herausgerissen hat aus der Unzuverlässigkeit, dann ist sie schlicht das falsche Mittel. Dann müssen wir ein anderes suchen.

Und genauso die Agilität: Wenn die nach 10 Jahren noch am Anfang steht bei dem großen Hype, den sie erfahren hat, dann müssen wir uns etwas anderes suchen, um die Probleme, die immer noch so weit verbreitet sind, zu lösen. Dann ist irgendetwas noch mindestens knapp daneben bei der Agilität.

Was mich also enttäuscht hat bei Martin Fowlers Vortrag war die ruhige “Sturheit”, mit der er “mehr vom Selben” wenn schon nicht gefordert, dann doch aber suggeriert hat. Mehr “richtige” Objektorientierung hilft, mehr “richtige” Agilität hilft. “Leute, haut einfach rein; ihr habt es noch nicht doll genug versucht.” Klingt wie aus einem Watzlawik-Buch. Nur da wird solches Verhalten leider als pathologisch entlarvt.

Das Ergebnis des Abends für mich: Martin Fowler hat für mich live repräsentiert, was ich nach Lektüre seines und anderer Blogs schon geahnt hatte. Die Vordenker von einst sind auch nur Menschen und können nicht dauerhaft vordenken. Auch sie sind Gefangene eines Systems, selbst wenn sie es selbst (mit)geschaffen haben. Oder gerade deshalb?

Wirklich Vordenkerisches werden wir kaum noch von Fowler oder Martin oder Beck zu hören bekommen. Alistair Cockburn scheint mir allerdings noch etwas wacher. Ansonsten schauen wir besser an den Rand des Mainstream. Dort steigen die Nebel dessen auf, das sich dermaleinst zum Software Design des 21. Jahrhunderts verfestigen wird. NoSql, Erlang, DCI, Kanban… das sind für mich Begriffe, die Impulse in die Branche senden.

Keine Ahnung, wie das aber alles mal am Ende aussehen wird. OO und Agilität und DSLs und REST werden dadurch natürlich auch nicht von der Bildfläche spurlos verschwinden, sondern vielmehr assimiliert. Aber die Softwarentwicklungswelt wird anders aussehen, da bin ich mir sicher. Denn wenn sie nicht anders aussieht, dann habe ich wenig Hoffnung, dass wir uns aus dem wachsenden Brownfield befreien.

Kommentare:

Tronex hat gesagt…

Ich hatte ursprünglich geplant, ebenfalls zu dem Vortrag zu kommen. Deine Erläuterung zu dem, was es zu hören gab, bestätigt mich in meiner meiner Vermutung... ich habe nichts verpasst.

Nachdem ich vor über zehn Jahren das erste Mal nach Assembler, Pascal und C den Sprung nach C++ gemacht hatte (und damit an einem der wenigen objektorientierten Spieleentwicklungen teil hatte), kam bereits der Grundgedanke auf: OOP hat seinen Reiz... aber ist es das "Richtige"? Es fühlte sich falsch an.

Und heute sitze ich z.B. in einem Projekt, in dem es um die Migration einer Legacy VB6 Applikation nach VB.NET geht. Der Softwarearchitekt wird nicht müde zu erklären, dass OOP a) nicht das Ende der Fahnenstange sei und b) sowieso nichts taugt (und das obwohl er seinen Job richtig gut macht!).

Er sprach lange Zeit von seiner Vision sogenannter Software-Cells, die autonom agieren und ohne Abhängigkeiten miteinander kommunizieren können. Kommt Dir der Gedanke bekannt vor? :)

Dennoch: Ob OOP, EBC... oder meinetwegen Software-Cells. Ich bin der Meinung, dass wir uns damit zwar bereits auf den Lernzielebenen 3 und 4 tummeln (sprich: wir transferieren Bekanntes und denken problemorientiert), aber dabei jedes Mal den grundsätzlichen Fehler machen zu behaupten damit den optimalen Ansatz gefunden zu haben.

Vielleicht geht es aber auch nicht wirklich darum, Software durch Paradigmen wartbarer zu machen... oder durch Kapselung o.ä. evolvierbar... oder durch funktionale Ansätze performanter. Ich bin z.B. überzeugt davon, dass sich auch mit "archaischen" Programmiersprachen saubere, schnelle und wartbare Programme entwickeln lassen.

Vielleicht geht es darum, verdammt noch mal seinen Job gut zu machen. :) Und solange ungelernte "Programmierer" ins kalte Wasser geworfen werden und ohne die Möglichkeit des Lernens durch Üben einfach nur den Tag überleben müssen... (und das für 1.000 Euro Tagessatz; ja so etwas gibt es) solange werden auch nicht die besten Paradigmen helfen. Egal ob man sie mit greifbaren Analogien wie Objekten, Legosteinen oder Steckplatinen vergleicht, damit auch der letzte Depp begreift, womit er es zu tun hat.

Ralf Westphal - One Man Think Tank hat gesagt…

@Tronex: Ach, die Softwarezellen... sweet memories :-) Das ist weiterhin ein nützlicher Begriff in der Architektur, wie ich finde. Aber die machen von sich aus und allein natürlich keine "gute Software".

Ich höre bei dir recht generellen Frust raus. Kann ich verstehen. Und natürlich gibt es nicht die eine Silberkugel.

Bessere "Produktionsverhältnisse" sind natürlich eine Grundlage besserer Software. Das versuche ich allen Teams mitzugeben.

Am Ende bleibt für mich trotzdem eine Lücke. Wir brauchen in jedem Fall mehr Entwickler in der Zukunft. Und die können, selbst wenn die Ausbildung besser wird, nicht alle top notch sein. Also müssen wir Paradigmen, Methoden, Konzepte, Technologien, Tools haben, die auch mit dem Durchschnittsprogrammierer zu besseren Ergebnissen führen.

Wir können nicht alle Leute zu Elektrotechnikern ausbilden, also müssen Telekommunikationsgeräte einfacher werden. Das Ergebnis: das Telefon. Dito beim Auto. Dito überall sonst in der Welt.

Wir müssen die Sache, den Zugang vereinfachen, damit mehr Leute helfen können, damit Lösungen zu bauen.

Tronex hat gesagt…

@Ralf: Da gebe ich Dir Recht. In sofern verfolge ich die Evolution der EBC mit Spannung. Wie bei vielen "neuen" Erfindungen sind sie zurzeit noch groß und sperrig... und nur mit einer hohen Einarbeitungszeit verständlich. Aber wer vor 10 Jahren mit der MFC Oberflächen entwickelt hat kennt das... und heute gibt es den WinForm Designer (bzw. WPF & Co).

Vielleicht wird sich aus den EBC eines Tages eine eigene Syntax entwickeln. Eine eigene IDE (entsprechende Designer sind ja bereits am Start). Vielleicht wird sich die Komplexität hinter einem Vorhang verstecken, den nur noch die Architekten hier und da mal öffnen und von der die Durchschnittsprogrammierer genauso wenig mitbekommen wie heute von Zeigerarithmetik und Garbagecollection.

Und bis dahin werden sich sicher andere Probleme ergeben. Und damit schließt sich der Kreis. Wie Du schon sagtest: Es gibt keine Silberkugel, nur immer wieder neue Ansätze für althergebrachte Probleme.

Thomas hat gesagt…

Hallo Ralf,

ich weiß gar nicht über was der gute Martin Fowler sprechen wollte. Das ist auch gar nicht notwendig.

Ich für meinen Teil bin ein wenig frustriert. Ich gebe dir recht, Objekt Orientierung mag die Lösung für alle Probleme dieser Welt sein. Wenn keiner Sie so recht versteht, was soll’s, dann taugt es nicht.

Ich finde die Situation wie ich zurzeit vorfinde sehr ernüchternd. Das gilt für alle Bereiche der IT. Scrum wurde als heilsbringend eingeführt, aber nun nach 20 Sprints bleibt davon auch so viel nicht mehr über. Auf Konferenzen hört man dann immer „Wenn ihr Probleme habt, dann lebt ihr Scrum nicht richtig“ Das hört sich für mich wie ein selbsterfüllende Prophezeiung an. Ich behaupte einfach, wenn Scrum nicht flexibel genug ist um in eine bestehende Firmenkultur reinzupassen, dann suchen wir uns was anderes oder besseres.

In technischen Bereich, geht es genau so weiter. Dort gibt es viele Sachen die schön, hilfreich, nett oder „In“ sind. Ich arbeite zurzeit in einen Silverlight Projekt, da gibt es dann MVVM, wir haben MEF und RX Extension sind auch nett. Aber was ist das Problem mit all den Dingen. Sie scheinen auf Inseln zu leben. Alle diese Dinge leben in ihren „Scope“. Wo bleibt aber das, wie immer es auch heißen mag, was alles verbindet?

Ich kann mich „Tronex“ nur anschließen, vielleicht geht es nur darum einen guten Job zu machen. Dazu gehört für mich auch weiterlernen. Ich für mich kann nur sagen, was in den letzten drei Jahren gelernt habe, war mehr und intensiver als in den vergangenen 40 Jahren davor :-)

Für mich stellt sich die Frage wohin geht die Reise. Nehmen wir mal an wir währen 200 Jahre in der Zukunft und würden ein Studenten bei einen Referat der IT Geschichte über die Schulter schauen. Was würde er schreiben?

„Mit der Einführung von Scrum revolutionierte sich die Software Entwicklung ….“

Anonym hat gesagt…

@ Thomas lass Dich nicht von Geschweife und Gescwefel der falschen Propheten aufhalten: mach Dein Job! Die leben davon!

Ralf Westphal - One Man Think Tank hat gesagt…

@Tronex: Ich behaupte mal keck: Wenn man mit Flow Design arbeitet, dann ist eine Verbesserung der Situation möglich.

1. Mit Flow Design ist Architektur, aber besonders Modellierung in der Gruppe sehr gut möglich. Das bedeutet, mehr Input, mehr Kreativität, mehr buy-in (Motivation).

2. Mit Flow Design bekommt man am Ende so kleine Bauteile, dass die auch von Durchschnittsprogrammierern implementiert werden können. Die harte Arbeit ist vorher in der Gruppe gemacht worden.

Und dann sind Flow Designs auch noch unglaublich flexibel/evolvierbar. Was soll ich sagen... hört sich nach ner Silberkugel an :-)

Aber im Ernst: Wenn wir Funktionalität wirklich darstellen können (das geht mit Klassendiagrammen nicht), dann können wir gemeinsam dran entwerfen. Das halte ich für eine Kernpraktik.

Ralf Westphal - One Man Think Tank hat gesagt…

@Thomas: "Einfach den Job machen" hört sich gut an. Wenn denn klar wäre, was das genau bedeutet. Darüber ist sich ja die Branche nicht mal einig - oder glaubt, das Heil läge im Code allein.

Also hilft es alles nix: Wir müssen als Branche weiter nachdenken.

Sicherlich tut es gut, hier wie sonst im Leben, grobe Fehler einfach mal zu vermeiden. Grober Fehler #1: Druck ausüben, wo Kreativität gefragt ist. Grober Fehler #2: Leute zusammenwürfeln und glauben, sie seien dann gleich ein Team. Grober Fehler #3: Software in einem Wasserfall realisieren. Grober Fehler #4: Glauben, mit dem Wissen, was man mal irgendwann erworben hat, die nächsten 15 Jahre wuppen zu können. Grober Fehler #5: Pausenlos Produktionscode schreiben für nachhaltig halten. Grober Fehler #6: Anforderungen auf Zuruf irgendwie realisieren.

Hier höre ich mal auf. Mir fallen aber noch mehr grobe Fehler ein ;-)

Wenn wir aufhören, die zu begehen, dann wäre schon viel gewonnen, denke ich.

LosWochos hat gesagt…

...am Ende bleiben die ganzen Konzepte nur Hilfsmittel und Werkzeuge, um vernünftige Lösungen auf die Beine zu stellen. Und wie das mit den Werkzeugen so ist, kann ein Profi auch mit normalen Werzeugen etwas funktionierendes hinstellen. Ein Anfänger hingegen kriegt auch mit den besten Tools nichts auf die Reihe. Das ist aber keine Eigenschaft der Werkzeuge, diese werden nur benutzt (passiv!).

Florian Mätschke hat gesagt…

Entscheidend ist doch, dass Profis mit dem richtigen (professionellen) Werkzeugen die Vorarbeiten erledigen können, und die folgenden Arbeiten auch von einem oder mehreren weniger erfahrenen Anwendern erledigt werden können, und zwar leicht, strukturiert und gleichzeitig.

Zum Beispiel ein Tischler, der dir das Holz hobelt, richtig zuschneidet und Löcher an den richtigen Stellen vorbohrt.

Das Regal kann dann gemeinsam durch einfaches Stecken und Festziehen von Schrauben, gleichzeitig und gemeinsam leicht zusammengebaut werden. Das Prinzip kennt doch wirklich jeder, siehe z.B. dieses große schwedische Möbelhaus.

Dieses Prinzip könnte man leicht auf die Softwareentwicklung übertragen, z.B. mit EBCs.

Es bleibt nur die Frage, was passiert, wenn mal wieder eine Schraube fehlt... ^^

Thomas D hat gesagt…

Wer definiert eigentlich was "guter" Code ist? Besonders für Quereinsteiger wie mich ist das in der ganzen Diskusion schwierig einzuordnen. In der täglichen Praxis erlebe ich immer wieder wie "Vollprofis" mit dem größtmöglichen Aufwand den geringsten Nutzen produzieren. Eigentlich dachte ich, dass man so das Wort Hobby definiert. Aber mich beschleicht immer mehr das Gefühl, dass Programmierer täglich glauben ein neues Officepaket zu erstellen. Wie geht man aber an die vielen kleinen Projekte heran? Wie läßt sich da guter Code schreiben? Denn bedeutet nicht genau das "einen guten Job" zu machen? EBC sieht einfach aus und meine ersten Schritte damit scheinen das zu bestätigen.

Ralf Westphal - One Man Think Tank hat gesagt…

@Florian: Von dieser Art der Arbeitsteilung halte ich nicht soviel. Vorbereiten, vorbereiten, damit anderen dann gaaaanz einfach was zusammenstecken? Ne, da kommt dann schnell ein Verhau raus. Siehe Excel und Access.

Richtig finde ich es, wenn dieselben Leute in verschiedenen Modi arbeiten. Modus 1: kollektiver Entwurf; Modus 2: Implementierung, allein; Modus 3: kollektiver Review.

@Thomas: Was ist "guter Code"? Gute Frage. CCD versucht dafür Prinzipien und Praktiken unter den Leitsternen einige Werte zusammenzutragen.

Wenn ich die in Anschlag bringe und deinen Code anschaue... dann glaube ich, kann ich schon eine Aussage machen, ob der gut oder nicht so gut ist. Wichtig ist immer: Gut in welcher Hinsicht? Qualität braucht also Anforderungen, explizite Anforderungen.

Florian hat gesagt…

Hallo,

ich denke, dass wir als Softwareentwickler nicht einfach stur das anwenden, was sich momentan anbietet, sondern vielmehr, wie es in den CleanCode-Prinzipien auch steht, vielmehr in einem immer währenden Iterationszyklus über unsere Arbeit, die Werkzeuge, die Vorgehensweisen, ... reflektieren um daraus Verbesserungen des status quo abzuleiten.
Mit einer Reflektion ohne zeitlichen Druck kann dann auch die von Ralf schon erwähnte Kreativität miteinfließen, sodass sich neue Wege auftun. Ob es allerdings den goldenen Mittelweg gibt, der in allen Belangen absolut überzeugend ist, ist fraglich, denke ich. Allerdings suchen wir ja fleißig nach einem Ausweg, wobei sich auch hier durchaus Parallelen zur täglichen Arbeit zeigen, indem möglicherweise erst verschiedene Wege probiert und getestet werden müssen, nur um festzustellen, so geht es leider nicht. Nur haben wir keine Versionsverwaltung, in der wir wieder zu einem bestimmten Ausgangspunkt springen können.

Michael Hüttermann hat gesagt…

Danke für diesen interessanten Beitrag, der nachdenklich stimmt. Ich war zwar in München nicht dabei, hatte aber das Vergnügen vor wenigen Tagen Martin Fowler bei seinem Vortrag für die Java User Group Cologne sehen zu dürfen.

Auch in Köln hat Fowler eben diesen angekündigten Vortrag kurzerhand durch die zwei Talks "DSLs" und "10 Jahre Agile Manifesto" ersetzt. Ich möchte da nichts hinein interpretieren, und auch nicht den DSL-Beitrag zu hoch hängen wollen -- warum soll nicht auch Fowler auf diesem Wege, wie viele andere auch, sein Buch promoten.

Den Beitrag zum Agile Manifesto, so wie er in Köln gegeben wurde, fand ich schon spannend. Eine unterhaltsame Mischung "wie kam es dazu", "wo stehen wir" und "wo geht's hin" (somit also auf dem Weg zumindest ein kleiner Happen zum ursprünglich angesetzten Vortrag). Die Community-getriebene, abschließende Q&A war ebenfalls gut.

Personenkult hin oder her, ein Aspekt ist vielleicht auch, mit welcher Erwartungshaltung man den Ausführungen lauscht. Erwartet man, bei aufsteigendem Rauch, die vollständige Antizipation sämtlicher Entwicklungen der nächsten 100 Jahre (wie soll das gehen?) ;-), oder einfach Ausführungen eines wohlverdienten Experten, der in der Vergangenheit so falsch nicht gelegen haben kann, und vielleicht gerade durch (subjektiv) wenig Versuche von "Vorhersagen" damit ganz einfach den Status Quo unterstreicht. Wobei, nochmal: für meine Begriffe hat er in Köln ganz gut die aktuellen Tendenzen offen gelegt, und irgendwie sympathisch aus dem Nähkästchen geplaudert. Die Zwischennote "Dann halt nochmal 10 Jahre Agilität, damit es endlich jeder versteht" habe ich nicht wahrgenommen.

Einzelne Aspekte der IT will ich gar nicht bewerten, oder ob sich das eine oder andere quasi alle 10 Jahre wiederholt. Unterm Strich bleibt für mich hängen: der Vortragsabend in Köln war rundum gelungen, auch wenn es nur zwei Thoughtworker waren, die sich an dem anschließenden, leichtgewichtigen Beisammensein beteiligten, exklusive Martin Fowler.

ChinaFan hat gesagt…

Das Problem bei der OOP ist wohl sicher auch, dass man damit alles furchtbar kompliziert macht. Es wird immer mehr abstrahiert und generalisiert.
Sieht man sich mal die "echte" Win32 API an, reicht für ein konkretes Problem ein einfacher Funktionsaufruf.
Frameworks wie .NET, Java, etc. verschleiern das alles. Statt einen einfachen Funktionsaufruf, muss man erstmal mehrere Objekte erzeugen, diese zusammenstecken und bei einem bestimmten Objekt eine Methode aufrufen. Am Ende hat man vielleicht das Selbe erreicht, jedoch mit einem gewaltigen Overhead.

Objektorientierte Systeme sind auch schwerer zu verstehen, wenn man den Quellcode vor sich hat. Strukturell mögen sie sicher einwandfrei sein, aber das Verhalten lässt sich kaum nachvollziehen. (Von der schlechteren Performance ganz zu schweigen.)

Meiner Meinung nach verträgt sich das KISS-Prinzip so gar nicht mit der OOP.
Vielleicht sollte man wirklich mal einen Schlussstrich ziehen und nicht noch mehr Abstraktionsschichten auf bestehende Abstraktionsschichten setzen. (Siehe z.B. diese DSLs)

Drei Seiten fassen das IMHO sehr schön zusammen:
OOP Is Much Better in Theory Than in Practice
OOP Criticism
Three Big Lies

Ich "verfalle" oftmals in den prozeduralen Stil, weil er mir in sehr kurzer Zeit das bestmögliche Ergebnis liefert. Ganz im Sinne von KISS.
Zudem kann ich es leicht debuggen und Fehler aufspüren, weil ich nachvollziehen kann, was da gerade passiert. Viele verstreute Klassen würden da eher den gegenteiligen Effekt haben.

Naja, ich bin zumindest dabei, mich mit F# anzufreunden. Das fühlt sich mehr nach Datenverarbeitung an. :-)

Özcan Acar hat gesagt…

@ChinaFan: OOP ist nur ein Abstraktionsmittel. Das braucht man, um ein richtig großes Softwaresystem auf der höchten Ebene entwerfen und auch später nachvollziehen zu können. Die höchtste Ebene ist die, die für den Menschen am verständlichsten ist. Der Mensch braucht Abstraktion, um die Dinge besser auffassen zu können. Es mag sein, dass man auch eine Sache mit einem Funktionsaufruf erledigen kann. Das ist so, als ob ich wissen müsste, wie die Zündung im Zylinder eines Motorblocks funktioniert, wenn ich doch nur das Auto anschmeissen und losfahren wollte. Dieses Wissen brauche ich nicht. Das bräuchte ich, wenn ich den Motorblock designen wollte. Das wäre wieder eine andere Abstraktionsebene.

Wir sollten OOP nicht immer so schlehct machen. OOP allein bringt uns aber auch nicht weiter. Clean Code + OOP wäre vielleicht ein Ansatz. Es sollte immer in Richtung KISS gehen. Bei den meisten Projekten, die mit OOP-Mitteln realisiert werden, geht es genau in die andere Richtung. Daraus entstehen Systeme, die niemand mehr verstehen kann. Dann ist natürlich wieder OOP schuld :) Es kommt anscheinend auch ein wenig auf den Entwickler an..... Clean Code gewinnt immer...

Ralf Westphal - One Man Think Tank hat gesagt…

@Özcan: Da du sehr viel Vertrauen in OOP hast, würde ich mich freuen, wenn du erklären könntest, wie OOP (http://de.wikipedia.org/wiki/Objektorientierte_Programmierung) fähig ist, "um ein richtig großes Softwaresystem auf der höchten Ebene entwerfen und auch später nachvollziehen zu können."

Magst du das mal versuchen?

Özcan Acar hat gesagt…

@Ralf: Jetzt könnte ich viel über modulare Softaresysteme, Anwendung von DIP, SRP, OCP usw... erzählen, um deine Frage zu beantworten. OOP allein reicht nicht! Das habe ich auch in meinem Kommentar zum Ausdruck gebracht. Große Softwaresysteme sind nunmal sehr komplex. OOP hilft, mit Hilfe von Abstraktionen das gewünschte System zu bauen und zu verstehen, wenn die Abstraktionen gut implementiert sind.

Mit "auf der höchsten Ebene" meine ich die höchte Abstraktionsebe, die wie uns je vorstellen können. Das ist die Ebene, die uns verständlich macht, womit wir es zutun haben. Wenn OOP ein Werzeugkasten ist, dann habe ich die geeigneten Werkzeuge, um die gewünschte Abstraktion auszudrücken. Dazu hilft mir OOP, vorausgesetzt KISS, SRP und andere bewährte Prinzipien werden eingehalten.

Ich vertraue OOP, aber nicht den Entwicklern, die damit arbeiten. Erst muss ich den Code sehen, den sie produzieren :) Nur der Clean Code Developer mag die Abstraktionen mit OOP sehr elegang in Code giessen.

Ralf Westphal - One Man Think Tank hat gesagt…

@Özcan: Ich freue mich, dass du CCD einen so hohen Wert beimisst. "OOP ohne CCD reicht nicht", sagst du. Das finde ich auch.

Trotzdem sagst du, OOP sei das Mittel (welches im Rahmen von CCD gehandhabt werden soll), um "die höchte Abstraktionsebe, die wie uns je vorstellen können" zu programmieren.

Welche ist das aber? Wie sieht dann so ein Programm aus? Und dann: Was ist mit den anderen Abstraktionsebenen? Wie drückst du überhaupt verschiedene Abstraktionsebenen mit dem immer wieder gleichen OOP-Mitteln Klasse und Methode aus?

Ich würde das wirklich gern verstehen, weil du ein OOP-Enthusiast zu sein scheinst (der auch die Grenzen von OOP sieht).

ChinaFan hat gesagt…

@Özcan Acar:
Ich denke nicht, dass man die OOP braucht, um komplexe Systeme handhaben zu können. Mir scheint, uns wird das eher vom Mainstream so aufgezwungen und eingeredet.

OOP ist ein Paradigma unter vielen anderen. Und jedes Paradigma kann zum selben Ziel führen, wie ein anderes.

Was ist, wenn die Wahl des richtigen Paradigmas eine zutiefst individuelle und subjektive Entscheidung ist?
Jeder Mensch denkt anders und abstrahiert somit auch anders. Jeder kennt andere Rechenwege, kommt aber zum selben Ergebnis. Der eine ist Rechtshänder, der andere Linkshänder. Ein anderer wechselt spontan die Hände, ohne festes Schema.

Ich sehe hier tatsächlich Parallelen zwischen Rechts-/Linkshändern und OOPlern/Nicht-OOPlern.

(Dieses Dilemma vertiefe ich in meinem nächsten Blog-Beitrag.)

Ich möchte es fast nicht sagen, aber wir befinden uns schon in einer quasi OOP-Diktatur. Es wird alles nur noch in Objekten ausgedrückt. Man will sogar die Objekte in Datenbanken pressen. (siehe Hibernate)
Was ist aus den ganz normalen Daten geworden? ... den einfachen Zeichenketten, Zahlen, usw. die man einfach aus der Datenbank abfragen konnte?
Mir vergeht da ehrlich ein bisschen die Lust auf's Programmieren, wenn ich immer mehr Frameworks studieren muss, um eine simple Sache zu lösen.

mfg

Christian

Anonym hat gesagt…

Dieser Artikel zeigt interessante Sichtweise auf die letzte Dekaden der Softwareentwicklung.
Eins vorweg ich selbst Programmiere seit 18 Jahren, und somit kenne ich Assembler/Basic/C/C++ ect. pp. und was wichtiger ist deren Paradigmen (soweit ich dazu in der Lage bin/war).

Was witzig ist ich kann eure gemeinsame Erfahrung, das OOP scheiterte nicht teilen. Mir hat OOP viel gebracht um zb. mein code Jahre später noch verstehen und warten zu können. Auch halte ich sehr viel von Java/.NET OOP basierten Frameworks die mir täglich das Leben erleichtern.

Auch interessant ist, das ich eure Worte verstanden habe aber nicht deren Sinn. Ist Hammer ein schlechter Instrument weil Milliarden und aber Milliarden der Menschen seit tausenden von Jahren damit nicht umgehen können/könnten? Brauchen wir anderes Instrument zum Nagel einschlagen? Oder auf einem anderem Abstraktion Level sollen wir doch lieber Haus ohne Hammer bauen?

Ich kann in diesem Artikel eine andere Sichtweise Paradigma? als meine erkennen und ich mag die nicht. Wo ist Adoption, was ist mit guten Sachen mitnehmen? Stein in OOP Ecke werfen und seine Prozedurale hochloben ist nicht meins.

@ Thomas D hat gesagt...
„… wie "Vollprofis" mit dem größtmöglichen Aufwand den geringsten Nutzen produzieren …“ es kann aber sein das du den Nutzen nur nicht erkennen kannst, ein laufähiges Programm ist nicht per se das Ziel, auch nicht aus Business/Geldverdienen Sicht.

Ralf Westphal - One Man Think Tank hat gesagt…

@Anonym: Ich freue mich, dass du soviele gute Erfahrungen mit "normaler" OOP gemacht hast. Das ist toll - und vielleicht solltest du anderen Entwicklern beibringen, wie das geht. Denn wie die Realität der Ausbildung und der darauf folgenden Praxis zeigt, ist das nicht leicht. Es ist sogar so schwer, dass ich kein Projekt kenne, wo OOP in so guter Weise eingesetzt wurde, dass etwas gut Wartbares herausgekommen ist.

Ich behaupte also nicht, dass OOP schlecht ist. (Und auch ich verzichte ja nicht auf OOP.) Ich behaupte nur, dass es offensichtlich so schwer ist, OOP zu vermitteln, dass nicht verlässlich gute Softwarequalität herauskommt.

Das Ergebnis von 20 Jahren OOP-Anstrengungen widerspricht schlicht dem Anspruch von OOP. So einfach ist mein Urteil.

Anspruch und Realität laufen massiv auseinander. Und ich denke, wo das der Fall ist, da muss sich die Realität nicht länger verbiegen, um den Anspruch zu erfüllen. Dann ist es besser, den Anspruch, den Ansatz zu überdenken.

Ich will nicht glauben, dass Millionen von Entwicklern zu doof für richtige OOP sind und aus Doofheit Unwartbares herstellen. Aber selbst wenn das so wäre, dann muss sich halt die Methode dieser weltweiten Doofheit anpassen. Tut sie das nicht, ist sie schlicht arrogant.

Anonym hat gesagt…

Der Nutzen von OOP macht sich nicht in "besserer" Software bemerkbar, sondern in der Bewältigung wesentlich größerer Komplexität. Wo wären wir denn, wenn wir auf dem Entwicklungsstand vor OOP stehen geblieben wären? Es wären noch viel mehr Softwareprojekte gescheitert als ohnehin schon. OOP hat geholfen, Komplexität in erheblichem Masse besser zu bewältigen, als dies durch prozedurale Ansätze möglich ist. Aber wie jedes Konzept hat auch OOP seine Grenzen. Da Entwickler aber unersättlich sind und es immer schneller, höher, weiter gehen muss, wird kritisiert, dass OOP nicht die ultimative Lösung ist. Mit diesen Ansprüchen der Entwickler kann es eine solche Lösung garnicht geben. Ich behaupte: Es gibt keinen optimalen Ansatz. Die Erwartungen an jedes Konzept lassen sich immer so stark erhöhen, dass ein Konzept diese nicht mehr erfüllen kann. Die Komplexität von Software ist in den letzten Jahrzehnten erheblich gewachsen und OOP hat geholfen, diese Komplexität zu bewältigen. Damit hat es sich als tauglich erwiesen. Jetzt steigen die Erwartungen über die Leistungsfähigkeit von OOP hinaus an. Das ist normal und kein Mangel von OOP. Auch jede zukünftige Technik wird nur ein Schritt in der Entwicklung sein, der irgend wann durch gestiegene Ansprüche als nicht mehr ausreichend gelten wird.

Festplatten werden ja auch nicht als mangelhaft angesehen, weil sie trotz enormer Steigerung der Kapazität immer noch zu 90% voll sind. Und dieser Füllstand wird auch noch gelten, wenn Festplatten längst durch holographische oder andere Speichertechniken ersetzt wurden.