Autor Thema: Gang Of Four (GoF) Design Patterns für LotusScript on OO nachprogrammieren?  (Gelesen 34727 mal)

Offline koehlerbv

  • Moderatoren
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 20.460
  • Geschlecht: Männlich
Nicht labern, Axel, sondern machen! Ich bin wirklich an diesem Thread äusserst interessiert und beileibe nicht so "gelb", wie Du vielleicht denken magst. Gerade, weil Du diesen Thread führen möchtest, bin ich an Deiner non-pure-yellow-Sicht sehr interessiert und würde mich gerne beteiligen (sicherlich vorrangig lernend).

Mein Dank schleicht Dir jedenfalls schon voraus.

Bernhard

Marinero Atlántico

  • Gast
Erste konkrete Postings sind so zwischen Weihnachten und Neujahr zu erwarten, da ich zur Zeit einfach zu viel Arbeit habe, weil zum Jahresabschluss von Kundenseite mein natürlicher Feind (konkrete Ergebnisse) leider total hip sind.  ::)

@All: Meine Motivation wird es extrem steigern, wenn Fragen gepostet werden. Also so mehr aktives Lernen.
Mein mir vorschwebender Ansatz ist grade, dass ich sehr einfache Notes-Implementierung der gof Patterns schreibe und die Hintergründe eben gerade nicht aufschreibe. Bei meiner Paranoia alles "richtig" zu beschreiben würde das eh ziemlich langweilig.
Ich bin (noch) kein Weltmeister in LotusScript OO, weil ich da einfach noch nicht viel gemacht habe, werde es sicher aber schnell werden. Auf Fehler meinerseits bitte schonend aufmerksam machen. Nicht so unverschämt, wie ich das immer mache.

sincerely yours

a sinner

Offline animate

  • Freund des Hauses!
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 1.540
  • Uh, I'm just gonna go find a cash machine.
    • LA2
- Kappsele das, was sich ändern wird

Falls es jemanden interessiert - dieser kleine, unbedeutende und vielleicht sowieso logisch erscheinende Satz ist für mich (un sicher nicht nur für mich) der Schlüsselsatz überhaupt. Wenn du den kapiert hast und befolgst, dann bist du eigentlich schon ein guter Designer :)
Thomas

Fortunately, I'm adhering to a pretty strict, uh, drug, uh, regimen to keep my mind, you know, uh, limber.

Offline koehlerbv

  • Moderatoren
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 20.460
  • Geschlecht: Männlich
Absolute Zustimmung, Thomas. Und diese Stellen muss man erkennen (können). Ob man das dann DPs nennt oder anders oder ... sowas gehört zur absoluten Basis-Überlegung. Wird aber selten befolgt. Ich stolpere ja manchmal über Altlasten, und das schmerzt extrem. Schon der (ggf. Selbst-)Zwang zu "Ich schreibe das nur EINMAL !!!" zwingt schon zu extremen Verbesserungen.
Wie gesagt: Ich wäre gern dabei bei dieser Sache und bin fest überzeugt, dass ich da noch eine Menge lernen kann (wofür man ja nie zu alt wird, wenn die Sichtweise stimmt  ;) )

Einer der DP-Kenner sollte aber mal den Anfang setzen. Bei mir heisst das  gedanklich vielleicht nur alles anders, aber ...

Bernhard

PS: Dein Posting beim LotusGeek fand ich übrigens hochinteressant, Thomas. Ich mache sowas recht ähnlich, sollte aber noch mehr abstrahieren. Ob das dann DP heisst oder wie auch immer ... der theoretische Unterbau könnte / sollte bei mir durchaus dem aktuellen "Sprech" angepasst werden und natürlich mit BPs / DPs erweitert werden. Ich lerne gerne.

Offline TMC

  • Freund des Hauses!
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 3.660
  • Geschlecht: Männlich
  • meden agan
Nicht labern, Axel, sondern machen!
Also ich finde auch Theorie sehr interessant, so z.B. Axel's Posting #18 hier.
Irgendwann sollte es dann aber in die Praxis gehen  :)


Zitat
- Kappsele das, was sich ändern wird

Thomas / Axel:

Frage: heißt es nicht umgekehrt auch: "Kapsele das was sich *nicht* ändern wird" ?
(also typischescherweise in der LS-Programmierung die Auslagerung von immer wiederkehrenden Functions/Subs in ScriptLibs. Oder speziell bei der LS-Klassenprogrammierung die Auslagerung in Methoden. Typisch z.B.: das 1000ste ReplaceSubstring, eine Sort-Routine, etc. etc. Ich denke sowas wird man - sobald es mal steht - nur noch sehr selten ändern).
« Letzte Änderung: 22.12.04 - 21:36:35 von TMC »
Matthias

A good programmer is someone who looks both ways before crossing a one-way street.


Offline koehlerbv

  • Moderatoren
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 20.460
  • Geschlecht: Männlich
Matthias, natürlich gehört alles gekapselt, was irgendwann wiederkehren wird. Also sehr, sehr viel.

Ich habe dafür ScriptLibs wie
- BasicLib: Was jede DB braucht. Ich habe mir mittlerweile abgewöhnt, hier scheinbar "unnötige" Routinen pro App zu entfernen. BasicLib ist BasicLib, und fertig.
- ReportRoutines: Routines für das Logging (wenn erforderlich)
- AgentTools: Some tricky routines to manipulate the agent settings  ;D
- CommonAppLib (was die Klasse von Apps - so vorhanden - immer braucht)
- CommonAppUILib (was die Klasse von Apps - so vorhanden - immer braucht)

Und dann kommen SpecialAppLib, SpecialAppUILib etc.

Die Libs (ausser den Special...Lib) werden per %INCLUDE eingelesen. Wenn sich also eine neue Erkenntnis ergibt, ist überall Neukompilierung (und ggf. Anpassung) erforderlich, was ja bei den Basics nun überhaupt nicht schadet und dazu zwingt, "ein für allemal" gründlich zu programmieren.

Das war jetzt ein bisschen BP, aber nicht DP. Und es zwingt von vornherein dazu, wie man Libs sinnvol laufbaut (nicht, dass LibA LibB aufruft, diese dann LibC und diese wiederum LibA, was gerechterweise tierisch knallt und Kopfschmerzen bereitet, weil man 'ne Menge falsch gemacht hat).

Bernhard

Marinero Atlántico

  • Gast
O.k. die Idee dieses Threads besteht gerade darin, praktischen code zu produzieren und dann daraus Theorie, Terminologie, Konzepte, Klassifizierungen, etc. abzuleiten.
Nur dafür brauche ich eben mehr Ruhe, die ich ja auch bald bekomme (trotz extra gig am 28. + evtl. 29. inklusive real existierender Vorbereitung).
Aber noch ein paar Theorieschnippsel, weil ich das zufällig gestern abend noch im GoF Buch gelesen habe:

Zitat
- BasicLib: Was jede DB braucht. Ich habe mir mittlerweile abgewöhnt, hier scheinbar "unnötige" Routinen pro App zu entfernen. BasicLib ist BasicLib, und fertig.
- ReportRoutines: Routines für das Logging (wenn erforderlich)
- AgentTools: Some tricky routines to manipulate the agent settings  Grin
- CommonAppLib (was die Klasse von Apps - so vorhanden - immer braucht)
- CommonAppUILib (was die Klasse von Apps - so vorhanden - immer braucht)
Wie noch zu sehen sein wird, sind Patterns etwas anderes (soll sich dann aus den Beispielen erschliessen und es wie ihr wisst, geht es nicht um besser oder schlechter). 
Das weitestgehend sich auf c++ beziehende GoF Buch von 1995 bezeichnet solche wiederverwendkehrenden Libraries als
a) Toolkits
b) Frameworks
Patterns sind etwas explizit anderes.
Toolkits sind dabei wiederverwendbare Funktionsbibliotheken, die ein breites Anwendungsspektrum für einen Haufen an Stellen in einer Menge von Anwendungen haben, z.B. eine IO-Library oder eben sowas wie die beiden CommonAppxxx Libraries.
Frameworks haben ein enger definiertes Anwendungsspektrum. Z.B. ein Framework um alle möglichen verschiedenen Graphen zu erzeugen, oder pdf Dokumente, oder eben Agenten-Settings zu manipulieren (Notes) oder für Logging. 

In Java sind die Toolkits (und die Frameworks, etwa für Regular Expressions) Bestandteil der "core Library". Deshalb sind da so viele Klassen.

Patterns sind etwas weniger konkretes und code ist immer nur ein Beispiel für die Implementierung eines Patterns. Ausserdem sind sie "kleiner". Ein Toolkit oder ein Framework kann immer aus mehreren Pattern bestehen aber ein Pattern nie aus einem Toolkit oder Framework.

Hört sich erstmal esoterisch an, aber die Perspektive ist eben anders. Es ist noch nicht mal kompliziert.
 
Macht euch nicht so einen Kopf und wartet auf die Beispiele.

Patterns sind ausserdem für die Programmierpraxis etwas sehr konkretes. Gerade Einsteiger-OO Bücher stellen OO in aller Regel zunächst immer aus der Analyse-Perspektive da. Ein Aufgabenbereich wird als Klassen/Objekte wiedergegeben, die miteinander in Beziehung stehen, bzw. miteinander interagieren. Diese Klassen/Objete sind Repräsentationen von der realen Welt (Als Beispiel: Student, Kurs, Raum).
Wirklicher Code wird dann aber aus dieser Ananlyse-Perspektive in eine Design-Perspektive übertragen, woraus dann der code entsteht. Die Anwendung aus dieser viel code-näheren Design Perspektive sieht dann ganz anders aus. Eine Menge an Klassen sind einfach keine Repräsentationen von Objekten in der Realen Welt, sondern mehr so Dinge, die die Anwendung zusammenhalten. (s. Bilder: Eclipse screen shot ist code, was unmittelbar aus Design folgt. Anzahlmässig viel mehr Klassen als in Analyse.)
Und um herauszufinden, welche Klassen man braucht und wie man diese zusammensetzt, um eine Analyse umzusetzen, braucht es eben diese Pattern.
Und es gibt auch nur 23 GoF Pattern (sind aus OO-Sicht die fundamentalsten, die es gibt). Und die sind noch nicht mal gleich "wichtig". Und ausserdem ähneln sie sich teilweise sehr.

wenn das euch verwirrt, tut es als schöngeistiges Gequatsche ab

Axel

Beispiele folgen
« Letzte Änderung: 23.12.04 - 20:37:08 von Marinero Atlántico »

Marinero Atlántico

  • Gast
1.   Es gibt code.
2. Gof Design Patterns sind nicht irgendwelche „genialen“ Bibliotheken, sondern im-ersten-Blick-nicht-sehr-offensichtliche-echt wertvolle Hinweise zur Erstellung von flexibel anpassbaren OO-Code. Das Thema besitzt starke Abhängigkeiten zu anderen Teilen der OO-Theorie, so dass ich die erst mal versuche einfach darzulegen, wie ich diese sehe. Und zwar anhand von konkreten Code.

Ich habe beschlossen, die Designpatterns in eine Art Konsoleninfrastruktur mit LogDatenbank zu tun.
Dafür gibt es in Domino das Alog4.ntf template:.
Also bitte:
1.   Neue Datenbank erstellen
2.   Erweiterte Templates anhaken (show advanced templates)
3.   Agent Log auswählen (filename: alog4.ntf)
4.   Als Filename habe ich genommen HF_DP\ALog.nsf, als Name „Alog for HF_DP code“ (die krude Mischung aus Englisch und Deutsch ist so). Ihr könnt auch etwas anderes nehmen. Besser lokal installieren.


Als Datenbank für den Designpatterns code gibt es die Datenbank HF_DP.nsf (s. Attachment, im Administrator unterzeichnen ist immer eine gute Idee). Diese irgendwo besser im lokalen NotesData anlegen (z.B. im Verzeichnis HF_DP).
Wenn ihr die Datenbank auf eurem Rechner habt, geht ihr zur Ansicht Konfiguration. Da gibt es einen „Erzeugen/Konfiguration Logger“ Aktionsbutton. Das Dokument ist aber schon da. Dieses bitte bearbeiten. Ggbfls den Speicherort der Ressource LogDatenbank, die ihr eben erzeugt habt anpassen.

Die Werte sind:
Server:     (im Sinne von <leer>
Datenbankpfad: HF_DP\Alog.nsf
Default Identifier: DEFAULT (eigentlich egal)

Nun befinden sich in der Datenbank HF_DB 2 Skriptlibraries, in denen je eine Klasse das Auslesen des Konfigurationsdokument und die Kommunikation mit dem NotesLog-Objekt unterstützen (Designer öffnen und Überblick, nicht Durchblick verschaffen).
Dabei benutzt ein Objekt der Klasse Logger ein Objekt der Klasse ConfigDocWrapper (s. code).
Jede dieser Klassen hat 1, eine, una, one Aufgabe:
-    Logger regelt das mit dem Logging
-   ConfigDocWrapper kann Konfigurationsdokumente auslesen.

Gemäss objektorientierter Analyse sollen Klassen kohäsiv sein. D.h. sie sollen 1 thematische Aufgabe übernehmen. Manchmal ist es nicht so einfach herauszufinden, was nun sinnvollerweise 1 thematische Aufgabe darstellt. Oft ist es einfach.

Hier habe ich schon viel Unsinn in bestehenden code gesehen. Ich mein, man muss wirklich kein mega-guru sein, um auf die Idee zu kommen, dass eine Konstruktion mit zwei Klassen wo eine Klasse, die gleichzeitig xml schreibt, LSA Konfiguration ausliest, weitere Dateien erzeugt mit einer Klasse kommuniziert, die Notes Konfiguration ausliest und durch eine NotesView iteriert möglicherweise nicht so besonders gut thematisch gegliedert ist. 
Das aber nur am Rande, da es hier mehr um OO-Design gehen soll.

Ansonsten sind die beiden Klassen in den SkriptLibs in HF_DP.nsf von einem OO Standpunkt aus fragwürdig. Der Programmierer dieser Klassen besitzt vielleicht einen gewissen tragischen, möglicherweise genetisch bedingten Hang zur chronischen Underperformance. Gerade diese Schwächen können aber im weiteren Verlauf des Threads ganz nett sein, um OO-Design-Problematiken aufzuzeigen. Es wäre ganz gut, wenn die hier anwesenden Leute sagen könnten, wo aus ihrer Sicht die Schwächen liegen.

Diese beiden Klassen werden von den Agenten genutzt, in denen die Klassen für die weiteren Erörterungen drin sind. Erst mal ist dort der Agent DecoyDucksDontFly_Start mit den Klassen Duck, RedHeadDuck und MallardDuck. Es ist ein Entensimmulationsprogramm. Im Initialize des Agenten ist code, der Objekte der Klassen erzeugt und diese quasi als client nutzt.. Ihr könnt das erst mal ausprobieren, indem ihr diesem Agenten aus dem Notes Menü Agenten startet. Evtl. im Debugger anschauen was passiert.
Falls alles richtig läuft, werden ein paar Einträge in die Log-Datenbank geschrieben.

Logger benutzt ConfigDocWrapper, um die Log-Db zu finden.
Die Duck-Klassen in dem Agenten „DecoyDucksDontFly_Start benutzen Logger.

Marinero Atlántico

  • Gast
Ich stelle hier erst mal kurz die beiden Klassen wie sie in der Datenbank benutzt werden als UML Klassendiagramm dar. Damit kann man am ganz gut ein paar OO-Grundlagen erklären.
Statische Sicht (UML-Klassendiagramm):

Marinero Atlántico

  • Gast
Dieses Diagramm ist nicht so schwer zu lesen.
In den lustigen Karteikarten sind 3-teilige Dinger drin.
Oben in den 3-teiligen Dingern stehen Buchstabenfolgen drin, die extrem an die Namen der Klassen erinnern, von denen so eben die Rede war und die darüber hinaus auch noch im code der Datenbank stehen. Die 3-teiligen Dinger sind also Klassen.
Die sind in den Karteikarten drin und –aha- auf den Karteikarten stehen die Namen der SkriptLibs und Agenten, wo die Klassen drin sind.
Oben sind dann noch bekannte Domino Klassen.
Die Karteikarten heissen in UML packages. Die Notes-Klassen sind in einer –sagen wir – speziellen Art von packages namens Subsystem. So wichtig ist die Unterscheidung hier nicht.
Packages sind eine Art Container. Etwas, wo man was reintut. ScriptLibs und Agenten sind ja auch etwas, wo man Klassen reintut. Also passt dieses UML-Element wirklich sehr gut.

Die meisten Leser sollten schon mal gehört haben, dass Klassen Eigenschaften und Methoden haben. Im zweiten Teil der Klassen stehen die Eigenschaften und im 3. Teil die Methoden.
Das minus-Zeichen vor den Eigenschaften steht für den Zugriffs-Modifizierer private
Das plus-Zeichen vor den Methoden steht für den Zugriffs-Modifizierer public.
Was das genau ist, wird noch erklärt. Hier sind alle Eigenschaften private und alle Methoden public. Das ist nicht zwangsläufig so. Was es mit diesen Zugriffsmodifizierern auf sich hat, wird noch erklärt.
Die Domino-Klassen haben überhaupt keine Eigenschaften und Methoden eingetragen. Das ist aber nur, weil man in UML Teile weglassen kann. Die interessieren hier nicht und stehen sowieso in der Notes Hilfe.
Es interessiert mich nur, dass in den selbstgeschriebenen Klassen diese Domino-Klassen benutzt werden.

Zwischen den Klassen gibt es eine Menge Pfeile. An manchen steht <<is-a>>, aber an den meisten <<has-a>>. Wo <<is-a>> steht, sieht das Pfeilende anders aus als die wo <<has-a>> steht.
Normalerweise würde man in einem UML Diagramm nicht <<has-a>> und <<is-a>> reinschreiben, weil das in UML schon durch genau diese Formen der Pfeilenden ausgedrückt wird. Ich habs nur zur besseren Klarheit da reingeschrieben.

Beginnen wir mit den <<has-a>> Pfeilen.
Schaut euch die Klasse ConfigDocWrapper in der ScriptLib Configuration an.
Was steht dort oben:

   Private vw As NotesView
   Private docConfig As NotesDocument
   Private keyConfig As String

Und wohin gehen die has-a Pfeile von Configuration im UML-Bild??
Zu NotesView und zu NotesDocument.
Und was steht da oben??
DocConfig as NotesDocument und vw As NotesView.

In den anderen Klassen finden sich im Code die <<has-a>> Beziehungen auch in den Attributen wieder. Ist auch logisch. <<has-a>> im Sinne von „hat-ein“ ist vom normalen Sprachgebrauch so was wie eine Eigenschaft.
Ob man eine Eigenschaft im code in UML als has-a Beziehung oder als Eigenschaft (2. Teil von Klasse) modelliert, befindet sich sowieso im Ermessen des Modellierers. Es gibt gewisse Argumente, warum bestimmte Eigenschaften als has-A Beziehungen dargestellt werden, aber das ist hier kein UML-Kurs und erst mal nicht so wichtig.
Has-A Beziehungen werden auch als Composition bezeichnet. Ein wichtiges Motto der GoF ist: Favour Composition over Inheritance. Ihr müsst das jetzt nicht verstehen. Wird später erklärt. Einfach im Unterbewusstsein aufnehmen. Wenn ihr den Thread zu Ende gelesen habt, wacht ihr als C#.NET Programmierer auf 
Und die anderen Pfeile? Die is-a Pfeile?
Die stehen für Vererbungsbeziehungen (Inheritance).
A RedHeadDuck is a Duck.
A MallardDuck is a Duck.
Klingt logisch.
Und sieht man das auch im code?
Ja.
Public Class Duck
Public Class RedHeadDuck As Duck
Public Class MallardDuck As Duck

Das LS Schlüsselwort As steht für Vererbung oder anders ausgedrückt is-a Beziehungen.

In der nächsten Folge wird genauer die exakten technischen Wirkungen dieser Vererbung anhand des laufenden Codes erklärt (phate Debugger-Session). Diese sind in allen OO-Sprachen sehr ähnlich. Ihr könnt den Agenten starten und es euch schon mal im Debugger und der Log-DB anschauen. Vorweg schon mal das: (hab ich grad bei dem Microsoft Autor Jesse Liberty gelesen): Es gibt durch Vererbung aus Design-Sicht 2 Effekte:
-   tendentiell schon mal problematische code inheritance
-   als zweiten und wichtigeren Effekt Polymorphismus.

Danach wird der Code des Entensimulationsprogramms erweitert. Da wird deutlich, was an Vererbung problematisch ist und warum die GoF Autoren „Favor composition over inheritance“ für eine gute Idee halten. Das Dilemma des Entensimulationsprogramms wird durch das Strategy Pattern angegangen. Das wird die erste Anwendung eines Patterns sein. 

Tipp für Logger/ConfigDocWrapper-Bashing: Schaut auf die Abhängigkeiten. Die has-a Pfeile sind Abhängigkeiten. Welche konkreten weiteren Anforderungen können an diese Klassen gestellt werden (z.B. bei Wiederverwendung in einem konkreten anderen Kontext). Verbesserungsvorschläge?

Offline animate

  • Freund des Hauses!
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 1.540
  • Uh, I'm just gonna go find a cash machine.
    • LA2
Welche konkreten weiteren Anforderungen können an diese Klassen gestellt werden (z.B. bei Wiederverwendung in einem konkreten anderen Kontext). Verbesserungsvorschläge?

Also nix konkretes und nix was du nicht wüsstest, aber evtl. musst du mal deine Konfiguration woanders herholen oder/und dein Log woanders hinschreiben.
Verbesserungsvorschlag? Da das hier ja auch etwas eine Lehrveranstaltung ist, denke ich dass sich die, die was lernen möchten, dazu Gedanken machen und die Gedanken veröffentlichen sollten.  ;D
Thomas

Fortunately, I'm adhering to a pretty strict, uh, drug, uh, regimen to keep my mind, you know, uh, limber.

Offline animate

  • Freund des Hauses!
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 1.540
  • Uh, I'm just gonna go find a cash machine.
    • LA2
Welche konkreten weiteren Anforderungen können an diese Klassen gestellt werden (z.B. bei Wiederverwendung in einem konkreten anderen Kontext). Verbesserungsvorschläge?

Hmm, vielleicht doch besser was konkretes. Der Benutzer soll in der Datenbank konfigurieren können, ob er in eine DB oder in ein Textfile loggen will. Außerdem sind in Zukunft noch weitere Log-Formate geplant.
Thomas

Fortunately, I'm adhering to a pretty strict, uh, drug, uh, regimen to keep my mind, you know, uh, limber.

Offline TMC

  • Freund des Hauses!
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 3.660
  • Geschlecht: Männlich
  • meden agan
Verbesserungsvorschläge?

OK, wir haben hier mehrere Enten, die nach und nach ein paar Dinge machen sollen wie eben quacken oder schwimmen.
Beim Blick auf den Code fällt auf, dass
  • Set myRHDuck = New RedHeadDuck()
  • Set myMDuck = New MallardDuck()
jeweils über die ConfigDocWrapper - Klasse das Setup-Dok auslesen lässt.
Also View suchen, Dokument finden, Felder auslesen, etc.

Wenn man jetzt aber nun mit vielleicht 100 verschiedenen Enten zu tun hat, ist das performancemäßig wohl nicht das beste.

<Offtopic>
Im Code steht öfter If Bedingung Then Error 999.
Lt Help sollten sich user-defined Error in der Range zw. 1000 und 1999 befinden. Ist aber jetzt wirklich eine absolute Kleinigkeit, ist mir halt nur aufgefallen ;-)
</Offtopic>

Matthias
Matthias

A good programmer is someone who looks both ways before crossing a one-way street.


Marinero Atlántico

  • Gast
Dies sind 2 sehr gute Punkte.
Thomas hat auf die coupling Problematik aufmerksam gemacht, auf die ich noch weiter eingehen werde. Jedes der Objekte kümmert sich um sein Spezialgebiet (Logging und Konfigurationsdokument auslesen) und - was Sinn macht - sie kooperieren miteinander.
Trotzdem ist diese Kooperation irgendwie zu fest verdrahtet. V.a. benötigt man für die Konfigurations-Klasse in der Datenbank zwingend eine Ansicht "Configuration", was auch eine ziemlich mutige Voraussetzung ist (vielleicht existiert in einer bestehenden Datenbank schon eine Ansicht mit diesem Namen).
Die Klassen aber flexibler zu machen, hat einen Preis. Nämlich, dass die Klassen in der Benutzung ein bischen komplizierter werden. Dazu später mehr. Es wird in moderner OO-Design Literatur immer wieder darauf hingewiesen, dass man nicht Flexibilität um ihrer selbst willen einfügen soll, nur weil man das programmieren kann. Die Flexibilität hat immer den Preis, dass die Klassen etwas schwerer zu benutzen sind. Das ist also ein Abwägen nach dem Gesichtspunkt, wo Wandel der Requirements zu erwarten ist. Dort ist es dann sinnvoll, Flexibilität für etwas mehr Komplexität "einzukaufen".
Mathias sein Punkt war nicht unbedingt zu erwarten und deshalb sehr gut. Ich hab das aber auch so gesehen, als ich die Klassen programmiert habe. In anderen Programmierumgebungen wie z.B. C# würde man solche für alle Enten wiederverwendbare Objekte (nicht Klassen) entweder in einer static-Variable halten oder über eine Singleton-Factory erstellen (wird noch erklärt und die braucht auch dieses static-feature). Ich mach mal ein Java Beispiel mit Lazy Static Initialisierung, damit es klar wird, wie static eigentlich funktioniert. Ich find das durch solche Vergleiche LS OO klarer und nicht unklarer wird.
Wie man Objekte shareable zwischen mehreren Client-Objekten (in diesem Fall Enten) macht, halte ich z.Zt. für ein Problem, dass irgendwie gelöst werden muss. Es ist in der Tat eine Ressourcenverschwendung, dort jedesmal ein Objekt mit den einzelnen Properties zu initialisieren!!!
Eine Herausgeberin des Buches, von dem dieser Thread inspiriert ist (Head First Design Patterns), wird übrigens heftig von Domino Bloggern gelobhudelt. Sie ist übrigens auch Mitbegründerin...  :-X
http://hostit1.connectria.com/twduff/home.nsf/plinks/TDUF-68B2TR 

Offline Mark³

  • Senior Mitglied
  • ****
  • Beiträge: 386
  • Geschlecht: Männlich
  • Nordisch by Nature
    • Das Leben aus der Sicht eines Menschen
1. super interessante Artikelliste (Thread), ich werde am Ball bleiben

2. Ich finde Design Pattern und echte OO-Programmierung sehr interessant, habe bisher aber noch keine Notesentwicklung gesehen, wo sich das wirklich auszahlt. Zumal Klassen im Notes-Designer grundsätzlich total unübersichtlich sind, da sie nicht übersichtlich dargestellt werden. Benutzt ihr im echten Leben auch sowas in LS oder ist das nur Spielkram, weil ihr aus der Java bzw. C++-Ecke stammt?
« Letzte Änderung: 05.01.05 - 18:14:13 von mt69clp »
sagt Mark.



slowfood.de

Marinero Atlántico

  • Gast
habe bisher aber noch keine Notesentwicklung gesehen, wo sich das wirklich auszahlt.
Ich schon. Und zwar an verschiedenen Orten. Selbst ganz früher 1999/2000 bei Kasten haben wir Klassen benutzt. Z.B. für Tabellen-Sortierung und Dokument-Locking. 

Zumal Klassen im Notes-Designer grundsätzlich total unübersichtlich sind, da sie nicht übersichtlich dargestellt werden.
Was am schmerzlichsten fehlt ist auto-code completion. Ich tipp den Objektnamen rein einen Punkt und dann Strg-Alt und hab alle erreichbaren Methoden und Properties der Klasse.
Ansonsten finde ich es übersichtlicher als Skript ohne OO. Eclipse (meine Lieblings Java-IDE) macht natürlich vieles übersichtlicher.

Das ist das aber ein Mitmach-Thread und kein Bewunder-Thread.

Benutzt ihr im echten Leben auch sowas in LS oder ist das nur Spielkram, weil ihr aus der Java bzw. C++-Ecke stammt?
Ja. Logo. Ich programmiere Java/J2EE, Lotus Notes und bin .NET Selbstlernen.
Ich find den Begriff Spielkram auch nicht so treffend. Programmiersprachen sind nicht so wichtig. In Java/C++ gibt es natürlich mehr Möglichkeiten und man begreift da auch bestimmte Sachen, die es unter Lotus Notes nicht gibt.
Aber ich kenne sehr gute Lotus Programmierer und schlechte Java Programmierer.

Axel

Offline Semeaphoros

  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 8.152
  • Geschlecht: Männlich
  • ho semeaphoros - agr.: der Notesträger
    • LIGONET GmbH
Kann mich dem von Axel hier nur anschliessen, auch ich benutze OO in LS, würde wohl sonst nicht die Mühe auf mich nehmen, an der Lotusphere genau dazu einen Vortrag zu machen.
Jens-B. Augustiny

Beratung und Unterstützung für Notes und Domino Infrastruktur und Anwendungen

Homepage: http://www.ligonet.ch

IBM Certified Advanced Application Developer - Lotus Notes and Domino 7 und 6
IBM Certified Advanced System Administrator - Lotus Notes and Domino 7 und 6

Offline koehlerbv

  • Moderatoren
  • Gold Platin u.s.w. member:)
  • *****
  • Beiträge: 20.460
  • Geschlecht: Männlich
Jo, an OOP ärgert mich auch nur eines (abgesehen von der mangelnden Unterstützung durch die Notes Designer IDE): Und zwar immer, wenn ich feststelle, dass ich hinterher erkennen muss, dass ein scheinbar brauchbarer prozeduraler Ansatz sich hinterher wegen dem Verzicht auf OOP zum Klotz am Bein wird. Dann könnte mich mich immer in den Hintern beissen, dass ich es nicht gleich richtig gemacht habe.

Um den zwar drastisch sinkenden Anteil solcher Fälle weiter zu minimieren, hoffe ich darauf, bald etwas Zeit zu haben, um mir auch in diesem Thread weitere Anregungen holen zu können.

Auf jeden Fall: Danke, Axel, für Deine Mühen !

Bernhard

Marinero Atlántico

  • Gast
... wichtig ist v.a. den source code zu verfolgen. Da steckt meine Hauptarbeit drin. Wg. ansonsten viel Arbeit wird dies auch nicht wahnsinnig schnell aber stetig vorangehen.
Ich gewinne durch die Diskussion einige Ideen.

thx Axel

Z.B. muss das von Mathias wiederentdeckte "no-static-to-share-dependant-objects" anti-pattern von LotusScript dringend angegangen werden durch einen Workaround in eigenen code.

« Letzte Änderung: 05.01.05 - 21:47:07 von Marinero Atlántico »

Marinero Atlántico

  • Gast
Nun sollen erst einmal auf einige typische OO-Vererbungsphänomene anhand des eigentlichen codes aufgezeigt werden. Es geht um ein paar wichtige Details der Implementierung von OO in die Sprache selbst. Diese Implementierung ist übrigens in allen Sprachen gleich. Wer das jetzt versteht, hat direkt ein paar Punkte für C#, VB.NET und Java-Zertifizierungen im Sack.

Schauen wir uns zunächst die Resultate des Durchlauf des Agenten in der Log-DB an.

 

Impressum Atnotes.de  -  Powered by Syslords Solutions  -  Datenschutz