This article explores various design patterns for developing ...
Design patterns were originally codified in Gang of Four's ... Today we develop using mixed patterns typically called MVC, MVVM, MVP, MOVE, etc.
These patterns may be useful in developing clients which correspond to hypermied-oriented servers (DARRT, etc.)
JOSE vs PASETO...
If Zooko's triangle sufficiently maps to CAP theorem, we should abandon both in favor of CALM conjecture when dealing with identifiers in disorderly, declarative programming. Enables programming with guesses, apologies and promises.
By providing the programmer with a set of abstractions that are predominantly order-independent, Bloom encourages a style
of programming that minimizes coordination requirements. But as wesee in the destructive cart program, it is nonetheless possible to use Bloom to write code in an imperative, order-sensitive style. Ouranalysis tools provide assistance in this regard. Given a particular implementation with points of order, Bloom’s dataflow analysis canhelp a developer iteratively refine their program—either to “push back” the points to as late as possible in the dataflow, as we did in this example, or to “localize” points of order by moving them tolocations in the program’s dataflow where the coordination can beimplemented on individual nodes without communication. (https://dsf.berkeley.edu/papers/cidr11-bloom.pdf)
Permission management
Links relations in the data exchange format; also in the media type: https://www.wired.com/2012/07/squirrel/
- Embed WinAmp in an mp3, give it a wallet for engaging in PKI (openchain is arguably more decentralized than Bitcoin and we can use DID here)
Use configurable base directory in RequireJS. Related to Code On-demand.
- Periodic Table of Information
- Impossibility of Intent
- Philonomics (Generative Identity and mental models of identity systems)
- DualAPI
DO NOT VERSION only the base of the API; either all resources must be
versioned or no resource should be versioned. Links should be made available
for predecessor-versions.
- XDI graphs?
- Use hashed YUML as generic tokens for representing underlying domain model changes for discovery layer of periodic table of information based on PKI, etc.
- See https://en.wikipedia.org/wiki/VHDL
- Redux REST Actions https://github.com/icimslabs/redux-rest-actions
- yEd2Kingly (angular-state-management, ui-router, etc.)
- DHT?
Functional Programming achieves SOLD. Domain-specific Languages
See https://github.com/ddd-crew/bounded-context-canvas
See https://dzone.com/articles/streamlined-microservice-design-in-practice
See https://microservices.io/articles/scalecube.html
[a]-R-*>[b]
const cond = await D();
const F = () => {};
const G = () => {};
const C = (R) => {
R();
};
const S = cond ? F : G;
C(S);
const behaviors = [];
const behavior = () => {};
behaviors.push(behavior);
behaviors.push(behavior);
const F = (cond) => {
const D = {
P: () => behaviors[0],
Q: () => behaviors[1]
}
D[cond]();
};const extend = () => {};
const base = () => {};
const F = (cond) => {
if (cond) extend;
return base;
};
const M = await D();
F(M);P and Q could be the cached results of knowledge reasoners or ontology
checks available in Protégé (Fact++)
See https://www.w3.org/2001/sw/wiki/Category:OWL_Reasoner
Isn’t there a need for cacheing the results of the various reasoners in a FOL form? (https://www.w3.org/community/philoweb/2014/01/15/syllogism/)
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);
const P = 'aRb';
const predicate1 = (value) => value === P
const predicate2 = (value) => value ? 'created' : 'deleted';
const D = compose(predicate1, predicate2);
const Q = 'aRb';
D(Q);Use RxJS, ngrx, etc. https://resthooks.org, etc. Generally apply a publish-subscribe pattern. W3C has also worked on ActivityPub which involve subscription models which can be part of transaction script modeling or domain modeling.
Perhaps the Actor model of ActivityPub works well with Agent-centric models a la holochain, etc. But then again, data-centric approaches like Semantic Arts and MarkLogic (bitemporal data) give an alternative interpretation of these Data- and Agent-centric distinctions.
Also consider the Reactor pattern: https://www.npmjs.com/package/reactor-lib/v/2.3.3 Reactor can implement (im)mutability factors for Hypermedia-oriented Design.
Like many other rule languages including our earlier work on Overlog, Reactor updates mutable state in an operational step “outside Datalog” after each fixpoint computation. (https://dsf.berkeley.edu/papers/cidr11-bloom.pdf)
Generally CALM wants to unseat the assumption (axiomatic) in a schematism that suggests only storage semantics or coordination-based programs can be achieved according to CAP theorem. CALM conjecture proposes to use disorderly programming which distinguishes itself from temporal logic patterns like TLA+ (see SAM pattern).