If language is generative of communication and learning, what tools would condition the possibility or capability unique to language using living beings? Would it be that non-being confounds the enablement and realization of linguistic machining, languaging and the rest, categorized and classified as productivity, inference, representation and compositionality? Social animals often fail to express these properties even at the level of social praxis (praxeonomics), typically fashioning tools for individual, but not social use beyond mere triviality.

Since the advent of the conceptual scheme, academics and students have engaged in modes of discourse that divide along the distinction of the empirical verification of the effectiveness of learning styles. Should we wonder if programming styles are grounded in the same or similar ensemble of abstractions and representations, or patterns of recognition which would resolve in epistemic justifications that are networked information? Of course the credibility of lateral thinking and the non-standard model become those bases of cognitivity for which an educator or educologist is in want of principles to determine the spatiotemporal interlocking with the language-object as a meaning-tag engenders the information necessary for empirically-friendly development, description, interpretation and explanation of hypotheses. Should theories and conjectures gain competitive ground or establish ontological commitment across all modes of discourse, the application of Segmented Discourse Representation Theory (SDRT) suggests a tenable mapping between rhetorical relations and sensible relations (Contingent Computation. Beatrice M. …

Speaking from Kittler’s point[0], “information hiding” has become a principle of Good Language design; i.e. “encapsulation”, surviving the criticism railed against object-oriented languages (polymorphism and classical inheritance, too, are terrible ideas; but whatever, if an organization or client wants, then the customer gets). So this mentality is the basis from which I make these suggestions. “Hiding” things has become the rule of the day, and I don’t like that; if anything, I want to expose more of the “bare metal” of the underlying systems in the OSI model’s base layer, the Physical layer, to the developers as much as the users, but obviously in a way that is intuitive, meaningful, etc. toward better shared understanding of these systems. …

A reply to: https://www.academia.edu/s/6c35647205

As a philosopher, one has an obligation to (a) undermine the pervasive “technocratic delirium”, chauvinism, if you will, that plagues our world-thought and to (b) proclaim that we do *not* entirely belong to the world of objects of which designers[0] are seemly staunchly concerned to assimilate into; indeed, the philosopher’s goal is to remind us of the sacred, or in plainer terms: of what we already know, the questions our ancestors forgot to ask, of the fragility that subtends the sacred which is not nothing but other than experience, or what’s more: the expression, of its totality without totalization. …

“The public has no history and no future, the public lives in a golden moment created by a credit system which binds them ineluctably to a web of illusions that is never critiqued.” (Terence McKenna)

We’ve stumbled into a restless web. It lacks the properties of

• Universality (Tim Berners-Lee) and Accessibility
• Durability (Gregory Bateson: A Recursive Vision)
• Convertibility (Pierre Klossowski)
• Priority (Transcendental “in-itself” or function, inclusion, radical presentation of history)

or elsewhere rendered as “CAP theorem” or Karpman’s triangle, and so on but so therefore lacks specification in describing the conditions for the possibility of, Mike Amundsen writes:

• Safety GET vs not-GET, correlates to which HTTP status codes? …

• Immutability, Composition of Representation (Fodor, cognition and systematicity), Attribute Mental Model, Openness to experience
• Safety (Amundsen/Lamport), Liveness (Lamport; SAM), Fairness (Lamport), Productivity (Fodor), Capability Mental Model, Agreeableness
• Idempotence, Systematicity of Representation, Relationship Mental Model, Conscientiousness
• Presentation, Transclusion, Systematicity of Inference, Neuroticism
• Space-time, Extraversion
• Honor-Dignity (Fourthness, C.S. Hermann)
• Honesty-Humility
• Gossip-sharing and Truth-finding, mutual respect, cosmopolitanism
• Abandon CAP theorem, embrace CALM conjecture (using abstractions like Guesses, Apologies and Memories): Coordination-free, Identification-free, Scale-free, Confluent composition
• Scale cube (Art of scalability: Y-axis, Y-axis, Z-axis scaling)
• Language security, formal input specification languages, full input recognition, Context-free grammars, Turing-complete power and Winograd Schema Challenges
• Computational aesthetics: representationality, instrumentality, cognitivism: “The enormous workload of today’s executives is another direct consequence of the conflict between biological time and computer time.” (The Hidden…

As a media type developer, we typically are mildly bemused by some questions of whether the “front end” and the “backend” should exist in the same code repository. In truth, the entire distinction between front end and backend is a bit curious in and of itself, since developers tend to share code styles, patterns and anti-patterns as well as norms and values about what counts as “good” or “performant” or “relevant” or “clever” code.

Generally, it’s just a bunch of nodes talking to each other. Computers do not know they are “front ends” or “backends”, this must be stated in the request-response volley of messages. One says GET the other has some Accept headers, and on so, but in truth at any time a server can become a client, depending on the goal that we has humans have set before us, whether it is to decentralize an economy or simply serve up a web page with a picture of a kitten on it. …

I’ve just been reviewing some alternative concept map visual forms for my original diagram created for Domain-driven Hypermedia-oriented Design. Oh, and it’s been updated:

Think of them as metaphors, conduit metaphors, through which to frame thinking terms for talking about the concept map. Some look like train station maps, some look like apartment buildings turned on their side. Others seem to suggest build in this direction (like the “bullet” looking one: reading from the domain-first toward the resolution right-to-left, the direction the bullet points; so maybe flip it around? ¯\_(ツ)_/¯), or “chronologically”. Of course the tabular one is very nice to reason and plan about and through.

Bullet

link dump. that’s it

extended here

the web fundamentally is a distributed hypermedia application

• browser controls https://roca-style.org/#server-side
• AngularJS ui-router https://ui-router.github.io/ng1/tutorial/hellogalaxy
• angular-state-machine https://github.com/tafax/angular-state-machine
• angularAMD https://github.com/marcoslin/angularAMD
• hypermedia controls https://github.com/petejohanson/angular-hy-res (other examples https://dev.to/daniellittledev/type-safe-hypermedia-controls-8le)
• restangular https://github.com/mgonto/restangular (still needful?)
• ng-a11y https://github.com/dequelabs/ngA1 [see figure 1]
• require-css https://github.com/guybedford/require-css
• use amundsen’s DARRT with https://github.com/badgateway/ketting/wiki/Hypermedia
• sam-angular https://github.com/brusand/sam-angular (e.g.)
• clusterluck https://www.npmjs.com/package/clusterluck
• paseto https://developer.okta.com/blog/2020/03/23/microservice-security-patterns#use-paseto-tokens-over-jwt (if you must use session)
• abandon CAP theorem, embrace CALM theorem
• hypermedia-oriented design, richardson maturity design model, hypermedia view-based design, hypermedia modeling
• segmented discourse representation theory (sdrt) model
• odrl model
• wai-aria model
• rail model https://web.dev/rail/
• prpl pattern https://web.dev/apply-instant-loading-with-prpl/
• xdi/rdf/schema.org/etc.
• core/coap > mqtt
• async REST, ARREST, resthooks.org, https://github.com/badgateway/ketting/wiki/Hypermedia, etc.
• microservices: use scale cube (https://microservices.io/articles/scalecube.html)
• microservice design canvas (https://dzone.com/articles/streamlined-microservice-design-in-practice)
• use YUML (DDDers may enjoy https://github.com/jaime-olivares/yuml-diagram)

developers may wish to use ionic v4 (v1.3.3?, but install ionic@4 , etc.).

figure 1: