The Undisclosed Element and the [Tendrils] of Code Coupling.

I'll disclose some code here. It's my code, so I'm free to do this. These code disclosures are meant to elicit interest and hopefully a response by people who may be interested in what I'm doing. That's the theory; I don't know the reader's mind, but one hopes the reader is one who has scruples enough to honour the fact that this idea is mine, and who will respect the fact that I have patented it.

This post, and the code disclosed therein demonstrate how complicated structural parameterisation can sometimes be; something of what some have come to see as a nuisance about Java. Java parameterises classes and interfaces through a mechanism called generic declarations. There's a lot about what a generic declaration is, so I'll leave it to the curious - but hitherto ignorant - reader to discover this wonderland. However, I need to put the mechanism into context here: generics bind one Java element (object, class, interface) to one or more others. When a class or interface is declared with a generic declaration that refers to another class or interface, objects of both classes or interfaces are bound by a "contract" which depends on some mutually recognised generic property.

Now, all this means that one or more objects is being structurally bound to others - increasing the objects' degree of coupling. This doesn't appeal to purist doctrine but there are plenty of times where this structural binding is absolutely necessary. My seven-Element (to be six-Element eventually - but that's another story) Client Device structure is one of these times.

The Client Device is loosely based around an arrangement of seven distinct, but related, Element types. At least one of each of these Element types are necessary to express one Client Device. Hence, one should be totally unsurprised to imagine that there would be a high degree of coupling between these Elements. Each element encapsulates a property of any device which is connected to a Clique Space(TM), so each Element describes only a part of the Client Device. Hence, the Client Device (the abstract representation of any device in Clique Space) and its constituent Elements is a prime component of the Clique Space concept. This particular Client Device mechanism was the epiphany I had in mid-2004 while jogging.

Working with generics in my implementation, I can see why some might become dismayed with what can sometimes become an intractable exercise that generates compile-time errors of sometimes frustratingly obscure origin. It almost seems that even a powerful IDE cannot help ease one's frustrations when it comes to getting code involving generics to compile. The relationships generics create do not appear to me to have an easily way to be visualised, so one really has to be careful and patient when one has to manage generic relationships between approximately 30 classes and interfaces - a structure not only as described, but a whole structure of subinterfaces, and their implementations for Elements as they manifest on the administrator Client Device, and the Agent Device.

Still, if one exercises patience against a solid application model defined around a clear concept, one can navigate through what may seem like a maze of these coupling relationships.

The massaged code snippet that I disclose is of a class called an undisclosed Element. This class is intended to be a substitute on the Client Device for situations where information about projected Elements and their identifiers is known to be missing, and this information cannot appear on the device's View, or persisted to a device activity audit log. Hence, the undisclosed Element and its identifier are used as place-holders whenever an Element or its identifier are known not to be projected. Instances of non disclosure could be the result of a lack of Limiting Constraint affinity between the user doing the viewing and the user being viewed, or if the user of a device collaborating with others isn't themselves connected to the same Clique Space or a federated neighbour Clique Space capable of sharing information about the user being viewed, or where the operator of the serving Agent Device to which the View device is connected has insufficient Limiting Constraint affinity; even though the operator of the View device may themselves, have sufficient affinity.

Instances where Elements might not be disclosed include, say, a user who lets you know what device they're using, and how they're using it, but not who they are (one can see that the Active Affiliation, Connection, Affiliation, Account Profile, and Media Profile are disclosed, but no Account has been likewise disclosed). At other times, say, a user may let you know who they are when you're letting them know who you are in some situations. In these cases, the Account may be disclosed for times when the particular user lets you know who they are, but in situations where they don't, an identifier relating neither the connection nor affiliation to their account will be likewise disclosed. So near, yet so far... and so very flexible.

In any situations where partial or non disclosure of Elements is apparent, the Client Device substitutes its undisclosed Element. This Element must have an interface that is compatible with every type of Element. It must therefore be structurally coupled to each Element's interface, expressing specific behaviour of the undisclosed Element which is compatible with all of the other disclosed Elements in terms of how a particular undisclosed Element's type is represented.

So, here it is in all its syntactic glory - a compromise to accommodate the apparent limitations of this web log. I also think HTML is a distraction that is not worthy of me.

 39 /**
 40  *
 41  * @author owen
 42  */
 43 public class UndisclosedElement
 44 extends NonLocalElementImpl<
 45  NonLocalCliqueSpace<
 46   ?extends NonLocalElement,
 47   ?extends NonLocalAccount,
 48   ?extends NonLocalAccountProfile,
 49   ?extends NonLocalAccountProfileRoot,
 50   ?extends NonLocalMediaProfile,
 51   ?extends NonLocalMediaProfileRoot,
 52   ?extends NonLocalAffiliation,
 53   ?extends NonLocalActiveAffiliation,
 54   ?extends NonLocalClique>,
 55  UndisclosedIdentifier,
 56  IdentifierTransmitter,
 57  ElementToken>
 58 implements
 59  NonLocalAccount<
 60   NonLocalCliqueSpace<
 61    ?extends NonLocalElement,
 62    ?extends NonLocalAccount,
 63    ?extends NonLocalAccountProfile,
 64    ?extends NonLocalAccountProfileRoot,
 65    ?extends NonLocalMediaProfile,
 66    ?extends NonLocalMediaProfileRoot,
 67    ?extends NonLocalAffiliation,
 68    ?extends NonLocalActiveAffiliation,
 69    ?extends NonLocalClique>,
 70   UndisclosedIdentifier,
 71   IdentifierTransmitter,
 72   ElementToken,
 73   NonLocalAccountProfileNode<
 74    ?extends NonLocalCliqueSpace,
 75    ?extends AccountProfileNodeIdentifier,
 76    ?extends IdentifierTransmitter,
 77    ?extends ElementToken,
 78    ?extends NonLocalAccount,
 79    ?extends NonLocalAffiliation,
 80    ?extends NonLocalAccountProfile>,
 81   NonLocalMediaProfileNode<
 82    ?extends NonLocalCliqueSpace,
 83    ?extends MediaProfileNodeIdentifier,
 84    ?extends IdentifierTransmitter,
 85    ?extends ElementToken,
 86    ?extends NonLocalAccount,
 87    ?extends NonLocalConnection,
 88    ?extends NonLocalMediaProfile>,
 89   NonLocalAffiliation<
 90    ?extends NonLocalCliqueSpace,
 91    ?extends AffiliationIdentifier,
 92    ?extends IdentifierTransmitter,
 93    ?extends ElementToken,
 94    ?extends NonLocalAccount,
 95    ?extends NonLocalAccountProfileNode,
 96    ?extends NonLocalActiveAffiliation>,
 97   NonLocalConnection<
 98    ?extends NonLocalCliqueSpace,
 99    ?extends ConnectionIdentifier,
100    ?extends IdentifierTransmitter,
101    ?extends ElementToken,
102    ?extends NonLocalAccount,
103    ?extends NonLocalMediaProfileNode,
104    ?extends NonLocalActiveAffiliation>>,
105  NonLocalAccountProfile<
106   NonLocalCliqueSpace<
107    ?extends NonLocalElement,
108    ?extends NonLocalAccount,
109    ?extends NonLocalAccountProfile,
110    ?extends NonLocalAccountProfileRoot,
111    ?extends NonLocalMediaProfile,
112    ?extends NonLocalMediaProfileRoot,
113    ?extends NonLocalAffiliation,
114    ?extends NonLocalActiveAffiliation,
115    ?extends NonLocalClique>,
116   UndisclosedIdentifier,
117   IdentifierTransmitter,
118   ElementToken,
119   NonLocalAccount<
120    ?extends NonLocalCliqueSpace,
121    ?extends AccountIdentifier,
122    ?extends IdentifierTransmitter,
123    ?extends ElementToken,
124    ?extends NonLocalAccountProfileNode,
125    ?extends NonLocalMediaProfileNode,
126    ?extends NonLocalAffiliation,
127    ?extends NonLocalConnection>,
128   NonLocalAffiliation<
129    ?extends NonLocalCliqueSpace,
130    ?extends AffiliationIdentifier,
131    ?extends IdentifierTransmitter,
132    ?extends ElementToken,
133    ?extends NonLocalAccount,
134    ?extends NonLocalAccountProfileNode,
135    ?extends NonLocalActiveAffiliation>>,
136  NonLocalAccountProfileNode<
137   NonLocalCliqueSpace<
138    ?extends NonLocalElement,
139    ?extends NonLocalAccount,
140    ?extends NonLocalAccountProfile,
141    ?extends NonLocalAccountProfileRoot,
142    ?extends NonLocalMediaProfile,
143    ?extends NonLocalMediaProfileRoot,
144    ?extends NonLocalAffiliation,
145    ?extends NonLocalActiveAffiliation,
146    ?extends NonLocalClique>,
147   UndisclosedIdentifier,
148   IdentifierTransmitter,
149   ElementToken,
150   NonLocalAccount<
151    ?extends NonLocalCliqueSpace,
152    ?extends AccountIdentifier,
153    ?extends IdentifierTransmitter,
154    ?extends ElementToken,
155    ?extends NonLocalAccountProfileNode,
156    ?extends NonLocalMediaProfileNode,
157    ?extends NonLocalAffiliation,
158    ?extends NonLocalConnection>,
159   NonLocalAffiliation<
160    ?extends NonLocalCliqueSpace,
161    ?extends AffiliationIdentifier,
162    ?extends IdentifierTransmitter,
163    ?extends ElementToken,
164    ?extends NonLocalAccount,
165    ?extends NonLocalAccountProfileNode,
166    ?extends NonLocalActiveAffiliation>,
167   NonLocalAccountProfile<
168    ?extends NonLocalCliqueSpace,
169    ?extends AccountProfileIdentifier,
170    ?extends IdentifierTransmitter,
171    ?extends ElementToken,
172    ?extends NonLocalAccount,
173    ?extends NonLocalAffiliation>>,
174  NonLocalAccountProfileRoot<
175   NonLocalCliqueSpace<
176    ?extends NonLocalElement,
177    ?extends NonLocalAccount,
178    ?extends NonLocalAccountProfile,
179    ?extends NonLocalAccountProfileRoot,
180    ?extends NonLocalMediaProfile,
181    ?extends NonLocalMediaProfileRoot,
182    ?extends NonLocalAffiliation,
183    ?extends NonLocalActiveAffiliation,
184    ?extends NonLocalClique>,
185   UndisclosedIdentifier,
186   IdentifierTransmitter,
187   ElementToken,
188   NonLocalAccount<
189    ?extends NonLocalCliqueSpace,
190    ?extends AccountIdentifier,
191    ?extends IdentifierTransmitter,
192    ?extends ElementToken,
193    ?extends NonLocalAccountProfileNode,
194    ?extends NonLocalMediaProfileNode,
195    ?extends NonLocalAffiliation,
196    ?extends NonLocalConnection>,
197   NonLocalAffiliation<
198    ?extends NonLocalCliqueSpace,
199    ?extends AffiliationIdentifier,
200    ?extends IdentifierTransmitter,
201    ?extends ElementToken,
202    ?extends NonLocalAccount,
203    ?extends NonLocalAccountProfileNode,
204    ?extends NonLocalActiveAffiliation>>,
205  NonLocalActiveAffiliation<
206   NonLocalCliqueSpace<
207    ?extends NonLocalElement,
208    ?extends NonLocalAccount,
209    ?extends NonLocalAccountProfile,
210    ?extends NonLocalAccountProfileRoot,
211    ?extends NonLocalMediaProfile,
212    ?extends NonLocalMediaProfileRoot,
213    ?extends NonLocalAffiliation,
214    ?extends NonLocalActiveAffiliation,
215    ?extends NonLocalClique>,
216   UndisclosedIdentifier,
217   IdentifierTransmitter,
218   ElementToken,
219   NonLocalAffiliation<
220    ?extends NonLocalCliqueSpace,
221    ?extends AffiliationIdentifier,
222    ?extends IdentifierTransmitter,
223    ?extends ElementToken,
224    ?extends NonLocalAccount,
225    ?extends NonLocalAccountProfileNode,
226    ?extends NonLocalActiveAffiliation>,
227   NonLocalConnection<
228    ?extends NonLocalCliqueSpace,
229    ?extends ConnectionIdentifier,
230    ?extends IdentifierTransmitter,
231    ?extends ElementToken,
232    ?extends NonLocalAccount,
233    ?extends NonLocalMediaProfileNode,
234    ?extends NonLocalActiveAffiliation>,
235   NonLocalParticipant<
236    ?extends NonLocalCliqueSpace,
237    ?extends ParticipantIdentifier,
238    ?extends IdentifierTransmitter,
239    ?extends ElementToken,
240    ?extends NonLocalActiveAffiliation,
241    ?extends NonLocalClique>>,
242  NonLocalAffiliation<
243   NonLocalCliqueSpace<
244    ?extends NonLocalElement,
245    ?extends NonLocalAccount,
246    ?extends NonLocalAccountProfile,
247    ?extends NonLocalAccountProfileRoot,
248    ?extends NonLocalMediaProfile,
249    ?extends NonLocalMediaProfileRoot,
250    ?extends NonLocalAffiliation,
251    ?extends NonLocalActiveAffiliation,
252    ?extends NonLocalClique>,
253   UndisclosedIdentifier,
254   IdentifierTransmitter,
255   ElementToken,
256   NonLocalAccount<
257    ?extends NonLocalCliqueSpace,
258    ?extends AccountIdentifier,
259    ?extends IdentifierTransmitter,
260    ?extends ElementToken,
261    ?extends NonLocalAccountProfileNode,
262    ?extends NonLocalMediaProfileNode,
263    ?extends NonLocalAffiliation,
264    ?extends NonLocalConnection>,
265   NonLocalAccountProfileNode<
266    ?extends NonLocalCliqueSpace,
267    ?extends AccountProfileNodeIdentifier,
268    ?extends IdentifierTransmitter,
269    ?extends ElementToken,
270    ?extends NonLocalAccount,
271    ?extends NonLocalAffiliation,
272    ?extends NonLocalAccountProfile>,
273   NonLocalActiveAffiliation<
274    ?extends NonLocalCliqueSpace,
275    ?extends ActiveAffiliationIdentifier,
276    ?extends IdentifierTransmitter,
277    ?extends ElementToken,
278    ?extends NonLocalAffiliation,
279    ?extends NonLocalConnection,
280    ?extends NonLocalParticipant>>,
281  NonLocalConnection<
282   NonLocalCliqueSpace<
283    ?extends NonLocalElement,
284    ?extends NonLocalAccount,
285    ?extends NonLocalAccountProfile,
286    ?extends NonLocalAccountProfileRoot,
287    ?extends NonLocalMediaProfile,
288    ?extends NonLocalMediaProfileRoot,
289    ?extends NonLocalAffiliation,
290    ?extends NonLocalActiveAffiliation,
291    ?extends NonLocalClique>,
292   UndisclosedIdentifier,
293   IdentifierTransmitter,
294   ElementToken,
295   NonLocalAccount<
296    ?extends NonLocalCliqueSpace,
297    ?extends AccountIdentifier,
298    ?extends IdentifierTransmitter,
299    ?extends ElementToken,
300    ?extends NonLocalAccountProfileNode,
301    ?extends NonLocalMediaProfileNode,
302    ?extends NonLocalAffiliation,
303    ?extends NonLocalConnection>,
304   NonLocalMediaProfileNode<
305    ?extends NonLocalCliqueSpace,
306    ?extends MediaProfileNodeIdentifier,
307    ?extends IdentifierTransmitter,
308    ?extends ElementToken,
309    ?extends NonLocalAccount,
310    ?extends NonLocalConnection,
311    ?extends NonLocalMediaProfile>,
312   NonLocalActiveAffiliation<
313    ?extends NonLocalCliqueSpace,
314    ?extends ActiveAffiliationIdentifier,
315    ?extends IdentifierTransmitter,
316    ?extends ElementToken,
317    ?extends NonLocalAffiliation,
318    ?extends NonLocalConnection,
319    ?extends NonLocalParticipant>>,
320  NonLocalMediaProfile<
321   NonLocalCliqueSpace<
322    ?extends NonLocalElement,
323    ?extends NonLocalAccount,
324    ?extends NonLocalAccountProfile,
325    ?extends NonLocalAccountProfileRoot,
326    ?extends NonLocalMediaProfile,
327    ?extends NonLocalMediaProfileRoot,
328    ?extends NonLocalAffiliation,
329    ?extends NonLocalActiveAffiliation,
330    ?extends NonLocalClique>,
331   UndisclosedIdentifier,
332   IdentifierTransmitter,
333   ElementToken,
334   NonLocalAccount<
335    ?extends NonLocalCliqueSpace,
336    ?extends AccountIdentifier,
337    ?extends IdentifierTransmitter,
338    ?extends ElementToken,
339    ?extends NonLocalAccountProfileNode,
340    ?extends NonLocalMediaProfileNode,
341    ?extends NonLocalAffiliation,
342    ?extends NonLocalConnection>,
343   NonLocalConnection<
344    ?extends NonLocalCliqueSpace,
345    ?extends ConnectionIdentifier,
346    ?extends IdentifierTransmitter,
347    ?extends ElementToken,
348    ?extends NonLocalAccount,
349    ?extends NonLocalMediaProfileNode,
350    ?extends NonLocalActiveAffiliation>>,
351  NonLocalMediaProfileRoot<
352   NonLocalCliqueSpace<
353    ?extends NonLocalElement,
354    ?extends NonLocalAccount,
355    ?extends NonLocalAccountProfile,
356    ?extends NonLocalAccountProfileRoot,
357    ?extends NonLocalMediaProfile,
358    ?extends NonLocalMediaProfileRoot,
359    ?extends NonLocalAffiliation,
360    ?extends NonLocalActiveAffiliation,
361    ?extends NonLocalClique>,
362   UndisclosedIdentifier,
363   IdentifierTransmitter,
364   ElementToken,
365   NonLocalAccount<
366    ?extends NonLocalCliqueSpace,
367    ?extends AccountIdentifier,
368    ?extends IdentifierTransmitter,
369    ?extends ElementToken,
370    ?extends NonLocalAccountProfileNode,
371    ?extends NonLocalMediaProfileNode,
372    ?extends NonLocalAffiliation,
373    ?extends NonLocalConnection>,
374   NonLocalConnection<
375    ?extends NonLocalCliqueSpace,
376    ?extends ConnectionIdentifier,
377    ?extends IdentifierTransmitter,
378    ?extends ElementToken,
379    ?extends NonLocalAccount,
380    ?extends NonLocalMediaProfileNode,
381    ?extends NonLocalActiveAffiliation>>,
382  NonLocalMediaProfileNode<
383   NonLocalCliqueSpace<
384    ?extends NonLocalElement,
385    ?extends NonLocalAccount,
386    ?extends NonLocalAccountProfile,
387    ?extends NonLocalAccountProfileRoot,
388    ?extends NonLocalMediaProfile,
389    ?extends NonLocalMediaProfileRoot,
390    ?extends NonLocalAffiliation,
391    ?extends NonLocalActiveAffiliation,
392    ?extends NonLocalClique>,
393   UndisclosedIdentifier,
394   IdentifierTransmitter,
395   ElementToken,
396   NonLocalAccount<
397    ?extends NonLocalCliqueSpace,
398    ?extends AccountIdentifier,
399    ?extends IdentifierTransmitter,
400    ?extends ElementToken,
401    ?extends NonLocalAccountProfileNode,
402    ?extends NonLocalMediaProfileNode,
403    ?extends NonLocalAffiliation,
404    ?extends NonLocalConnection>,
405   NonLocalConnection<
406    ?extends NonLocalCliqueSpace,
407    ?extends ConnectionIdentifier,
408    ?extends IdentifierTransmitter,
409    ?extends ElementToken,
410    ?extends NonLocalAccount,
411    ?extends NonLocalMediaProfileNode,
412    ?extends NonLocalActiveAffiliation>,
413   NonLocalMediaProfile<
414    ?extends NonLocalCliqueSpace,
415    ?extends MediaProfileIdentifier,
416    ?extends IdentifierTransmitter,
417    ?extends ElementToken,
418    ?extends NonLocalAccount,
419    ?extends NonLocalConnection>>,
420  NonLocalParticipant<
421   NonLocalCliqueSpace<
422    ?extends NonLocalElement,
423    ?extends NonLocalAccount,
424    ?extends NonLocalAccountProfile,
425    ?extends NonLocalAccountProfileRoot,
426    ?extends NonLocalMediaProfile,
427    ?extends NonLocalMediaProfileRoot,
428    ?extends NonLocalAffiliation,
429    ?extends NonLocalActiveAffiliation,
430    ?extends NonLocalClique>,
431   UndisclosedIdentifier,
432   IdentifierTransmitter,
433   ElementToken,
434   NonLocalActiveAffiliation<
435    ?extends NonLocalCliqueSpace,
436    ?extends ActiveAffiliationIdentifier,
437    ?extends IdentifierTransmitter,
438    ?extends ElementToken,
439    ?extends NonLocalAffiliation,
440    ?extends NonLocalConnection,
441    ?extends NonLocalParticipant>,
442   NonLocalClique<
443    ?extends NonLocalActiveAffiliation,
444    ?extends NonLocalCliqueSpace,
445    ?extends NonLocalParticipant>>
446 {

Etcetera...

700 }

I will not disclose the entire body of this class. You might find that a relief, but I will at least disclose one of the overridden methods which contains a not uncommonly long signature.

541     @Override
542     public AffiliationIdentifier[]getAffiliationIdentifiers(NonLocalAccountextends NonLocalCliqueSpace,?extends AccountIdentifier,
543      ?extends IdentifierTransmitter,?extends ElementToken,?extends NonLocalAccountProfileNode,?extends NonLocalMediaProfileNode,
544      ?extends NonLocalAffiliation,?extends NonLocalConnection>account,NonLocalCliqueSpaceextends NonLocalElement,?extends NonLocalAccount,
545      ?extends NonLocalAccountProfile,?extends NonLocalAccountProfileRoot,?extends NonLocalMediaProfile,?extends NonLocalMediaProfileRoot,
546      ?extends NonLocalAffiliation,?extends NonLocalActiveAffiliation,?extends NonLocalClique>cliqueSpace) throws CliqueSpaceException {
547         AffiliationIdentifier[]afia={this.getAffiliationIdentifier()};
548         return afia;
549     }

Indeed, it's a bit bewildering, but apparently necessary. If you observe the relationship between the definition of this undisclosed Element and all the other Elements given in the class declaration, the pattern shows that the concept is strong, uniform, consistent, and efficacious. At least, that's what I'm asserting. Likewise, I assert this class discloses a very small part of an implementation of a novel and unique concept.

Client Device stabilisation.

Apart from some "testing", one certainly feels as though the interface between the Agent Device and the administrator Client Device has reached a state of completeness. This is the best work I've ever done.

A big "Guten Tag!" to all my German friends. Let me know what you think about Clique Space(TM) some time perhaps.

The Clique Space(TM) Client Device is a Lie Detector

Everything is a device in Clique Space. Agent Devices (those devices that make the Clique Space system) and Client Devices (any other device, including the administrator Client Device being developed in parallel to the Agent Device) are simply different devices to Clique Space. Agent Devices, being mere devices, are subject to the same control mechanism as any other device. This point is an important designed intention.

Agent Devices establish Connections amongst themselves through a process of engagement. The product of this process is something I have come to call a synapse - seeing as it appears remarkably similar to one of these.

Client Devices establish one or more Connections with one or more Agent Devices through a slightly different process, and although this process yields something similar to what the product for the Agent Devices is, the fact that the Client Device can engage with multiple Agent Devices (there is no real reason to say that a Client Device cannot engage a single Agent Device more than once, but I have yet to test such a scenario) allows the user of the given Client Device (should it be equipped with a View adapted to some medium) to detect lies.

Lie detection... how does this happen?

Well, the Client Device can't tell you who is doing the lying, but it can tell you that one or more of the Connections to the (serving) Agent Devices are sending information relating to one or more Elements that is inconsistent with one or more of the same Elements sent from one or more other of the serving Agent Devices; indeed, a form of lie detection. So, how does this work?

Summarily, Elements are sent from an Agent to a Client Device through tokens, and each token is kept by the Client Device until the token's serving Agent Device tells the Client Device to remove it. An Element is recreated as a composite of the different tokens. Hence, the term that I use to describe the exchange of a token: "projection" makes each token a little bit like a light beam projecting an image on to a screen. The more light sources one has, the more accurate one might expect the image to be.

Lies can be detected in two basic ways: 1. token inconsistency; should the details of any set of tokens describing an Element differ in ways that another set of tokens describe the same Element, then that Element is "token-inconsistent". 2. Element inconsistency; relating to the inter-Element relationships between two or more Elements, "Element-inconsistent" relationships become apparent when these relationships (say, between an Affiliation and its component Account) are found to contradict through Elements only once they are assembled. In the case of the Affiliation - Account relationship, this element inconsistency will become obvious if, when composing the Affiliation from its tokens, one or more of these tokens discloses a differently identified Account than the Account assembled from its tokens which is stating that it points to the given Affiliation.

In the case of the Element-inconsistent Affiliation - Account relationship, these relationships only become evident at the time of the Elements' assembly within the Client Device to which the tokens have been projected.

Such contradictions could point to some problem with the serving Agent Devices, but yet again, they probably also point to nefarious intent of the operators of the serving Agent Devices. So, if you're a Clique Space user, and you don't trust the opinion of the person operating a singular serving Agent Device, seek a second (or perhaps a third or a fourth) opinion and ensure safety in consensus through simultaneous Connections to multiple serving Agent Devices; preferably ones which each are operated by different individuals. No serving Agent Device's operator would (nor should they) ask that you only connect to a single Agent Device, or only restrict your connection to those Agent Devices operated by a given individual. If they do ask you, then just lie and say "of course I am".

Clique Space(TM) Progress Report. Another possible milestone... perhaps.

Evolution.

My prototype Agent Device appears to have many of the functional attributes it needs to set itself up, project Elements to connected Client Devices (capable of viewing Elements), and respond to commands from an administrator's Client Device, itself capable of viewing Elements albeit currently only through console output. Very nice.

I have often likened programming to crochet; sure as I am are the similarities between a nicely crafted algorithm and a nice lace doily. Clique Space, however, is a veritable Persian carpet.

What use the Active Affiliation?

I've been pondering whether the Active Affiliation serves any specific purpose for some time, having talked briefly about this subject before.

The Active Affiliation Element was intended as a kind of state-object that connected devices would acquire to indicate that the connection was authenticated. Devices that possess a View would then use their Active Affiliation to form a Clique with their serving Agent Device. Other devices that did not receive View information from the serving Agent Device would acquire Participants when engaged with relevant other devices in Clique Space, otherwise devices would possess a lone Active Affiliation when not engaged with other devices in any collaboration.

Now that I'm developing the concept, my understanding of the relevance of each of the pieces shifts and one consequence of this appears to be that I'm being drawn to the conclusion that the Active Affiliation is redundant, and the Participant can take on the intended 'authentication' purpose of the Active Affiliation implying that media spines might only have three vertebrae: the Media Profile, Connection, and Participant Elements. The serving Agent Device's Participant and the bipartite Clique in which both Participants exist, is generated for all devices -- the mode of which differs with the type of device and what state information it exchanges with the serving Agent Device through which the device is connected to the Clique Space in question.

All this leads more directly to the convenience, or rather, the very point of Clique Space: Cliques model collaborations. And because every device has to "collaborate" with a serving Agent Device, at a minimum every device must form a Clique with its serving Agent Device before any View or log-based device can observe this collaboration and discover other collaborations this device might be involved in which are being modelled (and possibly controlled) by the Clique Spaces over which their Cliques span.

Now, my proof-of-concept has been evolving for some time. While the removal of the Active Affiliation from the core data model will ultimately simplify the implementation, this procedure is to going to be messy. Obviously, I'm going to consider this issue for some time yet while other issues are worked through.

Clique Space(TM) administrator Client Device command grammar.

After committing my last revision (I think it was 478) which has seen a stable implementation of the Agent Device disengage process, I decided it would be a good idea to map the assortment of commands available to the Client Device in a reasonably formal grammar.

The notation I have ascribed to is my own, developed as I put the grammar together; it should be fairly easy to work out, and although the elements "schema:label" form may lend itself to a meta-notation, I have not given such a schema the little consideration required beyond this because I don't currently care to.

Here it is:

command:=

command-clause:without-delegate|

{keyword:with value:delegate-identifier command-clause:with-delegate}

command-clause:without-delegate:=

command-clause:disband|

{keyword:list command-clause:list-without-delegate}|

command-clause:connect|

command-clause:show-or-hide-Clique-Space|

keyword:help|keyword:exit

command-clause:list-without-delegate:=

command-clause:list-Clique-Space|

command-clause:list-structure|

command-clause:list-Clique-without-delegate|

command-clause:list-Element-without-delegate|

keyword:rmi|

keyword:tokens|

keyword:cliques|

keyword:cliquespaces|

keyword:elements

command-clause:list-Clique-Space:=

keyword:cliquespace value:Clique-Space

command-clause:list-structure:=

keyword:structure keyword-clause:Element-type value:Element-identifier

command-clause:list-Clique-without-delegate:=

keyword:clique [value:Clique]

command-clause:list-Element-without-delegate:=

keyword:element keyword-clause:Element-type value:Element-identifier

command-clause:connect:=

keyword:connect value: Agent-Device-name

[keyword:accountprofile value:Account-Profile-name]

[keyword:cliquespace value:Clique-Space-name]

command-clause:show-or-hide-Clique-Space:=

keyword:show|keyword:hide value:Clique-Space-name

command-clause:with-delegate:=

command-clause:Particpant-adapter|

command-clause:Active-Affiliation-adapter|

command-clause:Connection-adapter

command-clause:Participant-adapter:=

command-clause:list-with-delegate|

command-clause:disband|

command-clause:join|

command-clause:leave|

command-clause:deactivate-other|

command-clause:form-other|

command-clause:activate-other|

command-clause:disconnect-other|

command-clause:create|

command-clause:destroy|

command-clause:Active-Affiliation-adapter

command-clause:Active-Affiliation-adapter:=

keyword:deactivate|

command-clause:form-self|

command-clause:Connection-adapter

command-clause:Connection-adapter:=

keyword:disconnect|

{keyword:activate command-clause:activate-self}

command-clause:list-with-delegate:=

keyword:list command-clause:list-Clique-with-delegate|command-clause:list-Element-with-delegate

command-clause:list-Clique-with-delegate:=

keyword:clique delegate-token:Participant-adapter value:Clique-name

command-clause:list-Element-with-delegate:=

keyword:element delegate-token:Connection-adapter keyword-clause:Element-type value:Element-identifier

command-clause:disband:=

keyword:disband [value:Clique-name]

command-clause:join:=

keyword:join value:Clique value:Clique-Space value:Active-Affiliation-identifier*

command-clause:leave:=

keyword:leave value:Participant-identifier*

command-clause:deactivate-other:=

keyword:deactivate value:Active-Affiliation-identifier

command-clause:form-other:=

keyword:form value:Clique-name value:Clique-Space-name value:owner-Active-Affiliation-identifier

value:member-Active-Affiliation-identifier*

command-clause:activate-other:=

command-clause:activate-self value:Connection-identifier

command-clause:disonnect-other:=

keyword:disconnect value:Connection-identifier

command-clause:form-self:=

keyword:form [keyword:clique value:Clique-name] [keyword:cliquespace value:Clique-Space-name]

value:Active-Affiliation-identifier*

command-clause:activate-self:=

value:Active-Affiliation-identifier

command-clause:create:=

keyword:create

{keyword:account value:user-identifier}|

{keyword:accountprofile keyword:name [value:Account-Profile-identifier*]}|

{keyword:affiliation value:Account-identifier value:Account-Profile-identifier}

command-clause:destroy:=

keyword:destroy keyword-clause:non-spinal-Element-type value:Element-identifier

keyword-clause:Element-type:=

keyword-clause:non-spinal-Element-type|

keyword:mediaprofile|

keyword:connection|

keyword:activeaffiliation|

keyword:participant

keyword-clause:non-spinal-Element-type:=

keyword:account|

keyword:accountprofile|

keyword:affiliation

I believe this grammar discloses a lot about my concept. Although perhaps disclosure of this detail is fraught with intellectual property hazard, I hope it might stand as proof to some that what I am doing is of realisable value, and that some day, a society might actually pay me recognition for this value. These are the motivations for publishing.

Clique Space(TM): A disengaging development.

Earlier this afternoon, and although perhaps a bit rough, I can now get two Agent Devices to disengage. The engage/disengage process has a wonderful parallel to the notion of the Agent Collaboration. This is because, like the Agent Collaboration (a manifestation of a Clique Space), a relationship being formed in the engage process and destroyed in the disengage process between two Agent Devices can be modelled as a Clique. As I have said before, this product, representing precisely two conjoined Agent Devices, appears to me to necessarily mirror the function of a synapse.

Because Clique Space should be able to model any collaboration between (or even within) a device, Clique Space should be capable of modelling collaborations between its own components. Hence, this means modelling collaborations at two levels: 1; at the level of the engage/disengage Agent Device Clique Space's synapse, and 2; at the level of form/join/leave/disband Agent Collaboration Clique Space's Clique.

Now, it appears that I still have one substantial obstacle to realising a minimally functional prototype: the Agent Collaboration's pulse message. At this time, functional specifics of a pulse are very sketchy, and much more thought than has been the case up until now will be directed to this pulse thing. While I deliberate, I will revisit the Client Device with the hope of simplifying its command syntax. This will hopefully 1; make a demonstration easier to understand, and 2; allow me to add commands in a more orderly manner, which will hopefully simplify the introduction of commands concerning the pulse message.

The Client and Agent Devices are co-evolving components; a significant observable property of Clique Space's development process is how development alternates, and at times goes on simultaneously, between the Agent and Client Devices.