[Nodal-j-devel] Coding principles #1: Faceted interfaces

[Lee I. <le...@te...>]

[Where can I reference this from?]

The basic principle here is that we make various permissions
for an Object conform to different interfaces to that same object.
Each different interface encapsulates the operations possible
when a particular permission is available.

The canonical example of this is the Node interface, which at
its base has no access to content, modification or privacy
management.  It simply represents an ability to identify itself.
In order to access any of the other properties of a Node, it
is necessary to access a different interface, and each such
access involves a possible permission check.

interface Node {
   Name nid ();
   NodeContent content();
   NodeEditor edit();
   NodeHistory history();
   NodeManager manage();
};

For security reasons, it should not be possible to
type-cast the Node interface into a NodeEditor without having
gone through the edit() method (that is to create a full
implementation of all of the possible interfaces for a Node as
part of a single implementation of Node).

Now, there are two possible ways to manage the relationship
between the facet (e.g. NodeContent) and the top-level interface
(e.g. Node).  The first would be to have no particular relationship
at all and to simply have a pointer back to the parent interface
from the facet.  For example:

interface NodeContent : Content {
   Node node();  // Pointer to node such that this = node.content()
};

The other option is to inherit the parent interface from the facet.
For example:

interface NodeContent : Node, Content {
};

Since we cannot get to the NodeContent interface without going
through Node (and this is another principle of isolation of the
permission checking/granting methods that we should conform to),
it seems artificial and unwieldy for the client to have to think in terms
of two separate interface pointers when we are really talking about
an object for which we have extended our view.  We thus prefer the
inheritance method, and will adopt it throughout our design.