Mail von Uli Fouquet am 2. Juli 2008:

Am Mittwoch, den 02.07.2008, 11:20 +0200 schrieb Henning Hraban Ramm:

> Habe ich richtig verstanden, dass wir die grundsätzlichen
> Inhalts-Objekte nur IContainer implementieren lassen statt von einem
> BaseContainer abzuleiten?
> Oder beides, so wie beim Inhaltsobjekt (Student erbt von BaseItem und
> implementiert IStudent)?

Ersteres sollte genügen. Wir sollten allerdings nicht von IContainer
ableiten, sondern ein eigenes Interface definieren, z.B.
`IWAeUPContainer` oder so. Das kann am Anfang ein pures Marker-Interface
sein, also ohne Methoden, Attribute etc., und dann kann man schauen, was
wir von WAeUP-Containern generell erwarten. Das kann dann ins Interface
rein.

> Nochmal anders formuliert:
> Wenn eine Klasse von grok.Container erbt, muss sie dann noch
> grok.IContainer implementieren?

Sollte sie, aber das ist in diesem Fall eine implizite Angelegenheit, um
die wir uns nicht zu kümmern brauchen. Die Default-Implementierung
`grok.Container` sollte das für uns erledigt haben.

Die Sache ist bei uns eher so, dass wir einen mächtigeren Container-Typ
brauchen, der evtl. noch ein paar zusätzliche Sachen braucht und: wir
brauchen ein Unterscheidungskriterium, um WAeUP-Container von
gewöhnlichen Containern zu unterscheiden. Das ist bereits mit einem
Marker-Interface erledigt.

In gewöhnlicher Objekt-Orientierung macht man das über Klassen und
Vererbung, so wie das auch im Moment der Fall ist: die Views binden sich
an Objekte vom Typ `BaseContainer` (oder Ableitungen davon). Die Klasse
entscheidet.

In einer Komponenten-Architektur binden sich Views aber gern an
Interfaces, um für unterschiedliche Implementierungen offen zu sein.
Vielleicht wollen wir irgendwann einen anderen Containertyp bauen, der
aber das gleiche Interface wie WAeUPContainer implementiert und dann
sind die Views schonmal wiederverwendbar.

Die StudentContainer etc. können dann von grok.Container ableiten und
versprechen, IWAeUPContainer zu implementieren und ein Default-View
würde sich an IWAeUPContainer binden, während ein speziellerer View sich
weiterhin an StudentContainer binden könnte.

Um auch das Letztere ganz unabhängig von der Implementierung zu machen,
könnte man zusätzlich ein Interface IStudentContainer von
IWAeUPContainer ableiten (sowas ist möglich und korrekt), und
StudentContainer dann dieses implementieren lassen. Views für
IWAeUPContainer würden sich dann für StudentContainer-Objekte zuständig
fühlen, sofern nicht ein View existiert, der sich an das ganz
spezifische Interface IStudentContainer bindet.

<Blah-Schwafel-Sektion>

Die folgende Abschweifung ist nur abstraktes Geschwafel. Wer den
Oberlehrer-Mode abschalten will, kann weiter unten fortfahren ;-)

Der entscheidende Unterschied in dem ganzen Gewusel ist: in
herkömmlicher Objekt-Orientierung baut man eine `B ist ein A` Relation
über Ableitung von Klassen. In einer Komponenten-Architektur dient die
Ableitung von Klassen aber nur der eigenen Faulheit: um Tipparbeit zu
sparen (überspitzt gesagt). Die genannte Relation wird vielmehr über
Interfaces verwirklicht. `B ist ein A` gilt genau dann, wenn B und A
dasselbe Interface implementieren. Die jeweiligen Klassen (und ihre
Implementierung) sind dabei piepegal.

Ein inneres Warnsignal sollte bei Euch immer dann Aufleuchten, wenn Ihr
Klassen ableitet aber in der abgeleiteten Klasse genausoviel Code steht
wie in der Basisklasse. Z.B.::

 class A(object):
   name='foo'
   bar='baz'

 class A2(A):
   name='braz'
   bar='buzz'

 class A3(A):
   name='bruzz'
   bar='bla'

Da fragt man sich schnell, was die Ableitung gebracht hat. In einer CA
(Component Architecture) sähe das so aus:

  from zope.interface import Interface, implements, Attribute
  class IA(Interface):
    name = Attribute()
    bar = Attribute()

  class A2(object):
    implements(IA)
    name='foo'
    bar='baz'

  class A3(object):
    implements(IA)
    name='bruzz'
    bar='bla'

Das sieht zwar sehr ähnlich aus, hat aber entscheidende Vorteile, sobald
wir eine zusätzliche Funktionalität wollen. Nehmen wir mal die
Möglichkeit,  zu im- oder exportieren. Das ist eine andere
Funktionalität als, nun ja, A-isch zu sein. Wir erwarten klare Dinge von
einem Importer/Exporter::

 class IImportableExportable(Interface):
   def export():
       """Delivers all content as CSV data.
       """

   def import(data):
       """Stores the data.

       Data is expected to be a list of rows of a CSV file.
       """

Wie stellen wir aber Importer-/Exporter-Funktionalität in einer
Klassenhierarchie dar (wenn wir kurz zum ersten Beispiel ohne Interfaces
zurückkehren)? Wir würden wohl die entsprechenden Methoden `import` und
`export` in der Basisklasse implementieren, ohne große Hoffnung, dass
irgendeine abgeleitete Klasse diese Implementierung gebrauchen könnte.
Vielleicht lassen wir sie deshalb lieber gleich ganz weg. Hier fängt's
mit dem herkömmlichen Ansatz an,  haarig zu werden.

Mit Interfaces können wir hingegen einen Adapter schreiben, der uns
einen Importer/Exporter für spezielle Interfaces zur Verfügung stellt.
Wir könnten auch in unseren Container-Klassen direkt die entsprechenden
Methoden entwickeln und sie (zusätzlich) als `IImportableExportable`
registrieren lassen. Egal, wie wir das dann machen: wir haben ein
abstraktes Framework zur Hand, dass uns erlaubt, solche Funktionalitäten
getrennt voneinander zu behandeln. Ein View kann z.B. über Abfrage der
Interfaces überprüfen, ob er für sein Context-Objekt einen
Import/Export-Link zur Verfügung stellen soll, etc. Das ist nett würde
ich sagen, und gelebte Komponenten-Architektur :-)

Das sollte nur ein kleiner Anhang zu versäumten Themen auf dem Workshop
sein.

</Blah-Schwafel-Sektion>

> Ist es weiterhin sinnvoll, zwischen BaseContainer (IContainer) und
> BaseItem (IModel gibt's nicht - was anderes?) zu unterscheiden, so
> dass wir z.B. StudentsContainer und Student haben? (Ich nehme an ja,
> aber das mag in Zope 3 anders sein...)

Das ist bestimmt sinnvoll. Container sind was anderes als Item-Objekte.
Sie bieten eine unterschiedliche Funktionalität also sollten da auch
unterschiedliche Interfaces existieren. Auch hier können (sollten) wir
eigene Interfaces bauen. Das Gegenstück zu IContainer ist übrigens
IContained. Aber wir brauchen eigentlich beides nicht.

> Auch wenn das letztendlich ein Berufenerer ausführt, will ich's mal
> selber machen, um die Zusammenhänge besser zu verstehen.

Klar, hau rein! Ist nicht ganz trivial, was Du da vorhast, aber bestimmt
gut zum Lernen. Vielleicht hilft mein Gelaber oben ja ein bischen dabei.
