Wednesday, November 23, 2016

Even More Robust Engagement

This morning, I managed something that I hope will be somewhat significant. When two Client Devices engage each other, each Client Device creates something called a synaptic channel. Client Devices use these channel structures to send messages to and receive messages from each other.

Up to now, I had two message types: 1. a channel's message which was sent between two co-engaged Client Devices to let each other know that they are still interested in maintaining the engagement (one device has to send a channel message to the the second one before a cycle interval lapses, or the second assumes the first has lost interest in remaining engaged and hence destroys its channel) and 2. a subscriber's message which allows co-engaged Client Devices to communicate general state information. The second of these two message types had yet to be used.

I didn't like the channel's message. It separated the process of keeping channels open from the communication of state, and I didn't like this fact because the Client Device engagement is state information, and having the notion of engagement handled by a separate message was a complication that obstructed the implementation of an efficient way to relay state through a cluster of Client Devices. The channel's message was a good stop-gap way to get the Client Devices to work in a way that would be analogous to they way they would finally work while some of the background necessary to this final behaviour had yet to be developed. Now that the background has been developed, the time to remove the channel's message is upon me.

By removing the channel's message and using the subscriber's message for channel mechanics as well as general device state, I think I have come up with a near-final overall system for the representation and the communication of state. Hence, sate information as well as channel mechanics should now be handled by a single message - the subscriber message. Furthermore, the subscriber message can now be known merely as the message.

To make this feat possible, there is a very complicated structure and mechanism that culminates in the exchange of delegate Connection Limiting Constraint signals as the final part of the Client Device activation process. The channel of each of the two Client Devices currently in the process of engaging is finally activated when these signals are first exchanged, and continues until one of the devices detects that the other has not sent a signal before the channel's cycle interval lapses.

The code below, is a selective quote of the subscription's subscribe method. Limiting Constraints extend subscriptions, so this method applies to Limiting Constraints by virtue of this extension.

public final void subscribe(PostsynapticChannel channel,OutboundConnection subscriber)throws CliqueSpaceException{

    /*Uninteresting code removed.*/

    SynapseOwnerParticipant pIn=channel.getInboundSynapse().getOwner();
    LimitingConstraint lcIn=pIn.getLimitingConstraint(ClientDeviceMediaProfile.DELEGATE_CONNECTION);
    boolean cycleIn=this==lcIn;
    SynapseOwnerParticipant pOut=channel.getOutboundSynapse().getOwner();
    LimitingConstraint lcOut=pOut.getLimitingConstraint(ClientDeviceMediaProfile.DELEGATE_CONNECTION);
    boolean cycleOut=this==lcOut;
    OutboundConnection c=channel.getOutboundConnection();


            throw new Subscribe_FirstCycleSubscriberNotOutboundConnection();

        /*Uninteresting code removed.*/

    }else if(cycleOut&&c==subscriber){
        ChannelAdviser ca=channel.getChannelAdviser();
            throw new Subscribe_ChannelAdviserDoesNotExist();

        int ci=channel.getDrive().getCycleInterval();
            throw new Subscribe_CycleIntervalNotSet();

                throw new InterruptedException("Cycle interval exceeded; other Client Device is probably unresponsive.");
        }catch(InterruptedException ex){
            throw new Subscribe_CurrentAdviserHasBeenInterrupted(ex);

The method starts by ascertaining whether this subscription is a delegate Connection's Limiting Constraint to the synapse Owner Participant of either the given channel's inbound or outbound synapse, and sets cycleIn or cycleOut to capture the result of this interrogation. Next, the given subscriber is added to the set of subscribers known to have expressed an interest in this subscription.

The if statement combines the values of the earlier defined flags with the role the host is playing in the engagement process to determine whether or not the channel needs to be activated. To clarify the necessity of requiring the channel's methods isInitiator and isRespondent, the following code snippet shows how these methods work.

public boolean isInitiator()throws CliqueSpaceException{
    boolean isInitiator;


    return isInitiator;

public boolean isRespondent()throws CliqueSpaceException{
    boolean isRespondent;


    return isRespondent;
When the two devices are engaging (before the channels have been activated) each device is assigned a role; the device that started the engagement process is known as the initiator and the device that is responding to the initiator's engagement request is known as the respondent. These methods will return true for a particular associated role while the two devices are in the process of engaging. They will return false regardless of which role a host took in the engagement process after the engagement process has finished (when the channel has been activated), and the two devices are merely cycling the delegate Connection's Limiting Constraint messages so to keep the channel open.

Hence, the if part in the first code snippet will only be executed once on each Client Device for a given engagement process. One observes the call to the given channel's activate method, a call that is made once only for each engagement. The activate method sets the channel's isInitiator field to null.

In the else if block of the fist code snippet, one can observe that the previous adviser thread (a thread which advises the co-engaged Client Device of this host's interest in keeping the channel open) is retrieved. The first adviser's thread is created and started in the given channel's activate method. The current thread only has to wait for the cycle interval to elapse before it moves on - waiting longer than this will be useless because the channel will have been closed, and one would want to prevent the possibility that a hanging adviser hangs the current thread. The channels's drive is a thread which sleeps for the cycle interval, and is reawaken either by the expiry of this time, or by interruption. In this case, the drive, which should still be waiting for the cycle interval to expire, is interrupted by the current thread as the final action of this else if block. This else if block implements the to and fro mechanism that keeps a channel open because the drive, when interrupted, sets off a small train of processes which results in the delegate Connection's Limiting Constraint of the channel's inbound synapse Owner Participant to be transmitted to the other Client Device.

The mechanism still requires perhaps a little more development. I do fear that there remain some cases that are not covered because, again, there remain many unexplored use-cases which would have a bearing on this mechanism. Even though perhaps I might think this mechanism could very well be a culminating result of eight years and about four months of development of a concept which is more than 12 years old, there is yet more deliberation to come though possibly this is a stand-out moment in time for the development of Clique Space(TM).

Monday, October 10, 2016

Steganography: a method of identifying Elements signed by the Sovereign

Yes... I'm still working on it. I am a love slave to this Clique Space(TM) thing.

I've been thinking about how one might "digitally sign" an Element so that when it is transmitted amongst Client Devices, that subset of Client Devices which know the same Sovereign can automatically detect that this Element represents cognitive activity of the individual thus manifest. By gosh, the answer appears (currently) to use something called a steganograhical signature. Such a signature is buried within what to the uninformed Client Device appears as an identifier string made up of random bits, each as trivial as the next.

When a Client Device receives a surrogate, it attempts to extract the signature steganographically buried in the surrogate's identifier (perhaps a symmetric key derived from the Client Device's Sovereign) and if it is successful in this task, it subtracts this key from the identifier, reconstitutes the given Element with this difference as its identifier, and stores the Element inside the Sovereign as Elements known to represent the individual manifest by the Sovereign. If the Client Device is unsuccessful, the Element is reconstituted without translating the identifier, and the reconstituted Element is not added to the Sovereign.

When a surrogate needs to be created again, the identifier of an Element not added to the Sovereign is merely copied to the surrogate. However, the identifier of an Element that is known to the Sovereign will be steganographically signed, and the surrogate will be created using this signed identifier.

The signature is buried in the identifier's seemingly random bit pattern, and hence the identifier is also the instrument of authentication to each of those devices "in the know" (possess the same Sovereign). There is no need to transmit a separate signature with the identifier, and so, given a sufficiently strong steganographical scheme, identifier authenticity could never be repudiated.

Thursday, May 26, 2016

Hmmm... a relatively curious bit of code...

At approximately 8:25am AEST on Saturday 28 May 2016, I wrote the following code:

public void execute(PostsynapticChannel channel)throws CliqueSpaceException{

    Identity author=this.authorSurrogate.asQuale();

    // The receiver's identity will always be signed by this Client Device's Sovereign.
   Subscription su=this.subjectSignal.asSubscription(


This particular code, comprising the non-trivial part of the SubscriberMessage's execute method will dispose of a subscription, created or retrieved from the signal disclosed in this subscriber message, if the carrier's contemplate method returns false.

The subscription's carrier is the object that contains the subscription. The carrier will be the subscription itself if the subscription is an Enabling or Limiting Constraint, otherwise (if the subscription is a principle's subscription), will be the principle that contains the subscription. Principles convey specific information about the specific context represented by the subscription. Principles are customised by Media Profile vendors to create subscriptions that exhibit a certain behaviour.

The carrier is a very important structure because it provides the opportunity for the subscription to behave in ways that are appropriate for the specific subscription. It is like providing for a mechanical system the opportunity to think in ways that are as diverse as say, thinking about what to do about having a drink versus the visceral feeling of having a thirst that needs to be quenched. While both of these are the products of neural activity, the first is a product of cognition that needs to be remembered so that the physiological arousal given in the second example can be meaningfully satiated. Once the urge is satisfied, its accordant state can be forgotten, without forgetting the cognitive process of quenching one's thirst.

Hence, a carrier can treat its subscriptions according to that carrier's particular function; does that carrier remember something about how to quench one's thirst, or does the carrier perhaps provide something toward the arousal of thirst. Both carriers are necessary cognitive facilities in the individual, and both have their own particular contexts. The contemplate method customises the carrier's behaviour in relation to this context. Principles hence implement the contemplate method with appropriate behaviour.

Monday, February 8, 2016


About an hour ago, I finally got three Client Devices (two Agent Devices and an administrator client) to maintain three sets of stable synapses between each other.

I'm going to go to my Alma Mater to have a go at selling my idea tomorrow. Maybe perhaps someone will be receptive to what I've got to show.

Thursday, January 7, 2016

Still here.

I'm still here. Still getting this Clique Space(TM) thing to work.

However, I fear that the things I'm working on at this point in time are not protected by my patent. They feel significantly different to the scheme published in the patents that I think disclosing them on this blog at this point in time would risk letting ideas escape into the public domain.

The patents (3 of them covering the Australian, US and New Zealand jurisdictions) talk of what components would need to form the bases of a real-time communications medium capable of representing individuals as a collection of devices that each operate. These patents form the shell of the idea.

I feel that the development of these ideas has created mechanisms that go deeper than the shell of these ideas; that I have penetrated this shell into the soft inner form to which I had only faith in the shell's containment as a guide.

I had faith because I had no idea of what was within when I put my ideas to a patent. I thought the ideas disclosed a simple system; maybe it is a system that is too simple for me to comprehend. Although I am now navigating a world where contingent ideas to those disclosed in the patent dominate, my faith hasn't wavered yet. I guess I might never finish. I may chase my tail to my end.

Thursday, September 17, 2015

Data model.

I've decided to disclose a data model for Clique Space. This has come about because of a discussion I had with someone who advised me to provide some pictures that help the reader understand the Jericho document I disclosed in my last post.

If Clique Space(TM) is a thing that is good, I want it to be known that I came up with it. Hence, this entry is me making a pre-emptive claim to this concept.
Although this isn't a full disclosure, perhaps the disclosure that I do provide is enough for someone else who has more money than myself to take and make even more money from. Perhaps such a person doesn't wish to let this world know that they have taken my ideas and claimed them as their own.

I know... I'm perhaps a bit paranoid. I think I'm dealing with it. Let Clique Space be mine or let it be no one's. If it is any good, what good would it do to continue to keep it away from this world.

Monday, September 14, 2015

Jericho Identity Commandments.

I have been trying to find a way to express my concept to others who might be thinking of similar things. I did some research recently and found this site and this site refer to a list of use-cases that people would generally like to see in a system that conveys identity.

I made general enquiries to these groups and someone from the second group got back to me. They directed my attention to the Jericho Identity Commandments and invited me to answer this wish list with solutions as I saw them in terms of Clique Space.

You can view my answers here.

Note also that I'm going to try to publish newer versions of this document when (or if) I receive constructive feedback from people who read it. That feedback could be from you. Your name could end up in the table of changes, or I will certainly honour your wish not to publish your name. Let me know.