DEV Community: ⚫️ nothingness negates itself

Answer: Am I suffering "divitis"? (CSS especialist needed) [closed]

⚫️ nothingness negates itself — Mon, 24 Jan 2022 11:56:55 +0000

answer re: Am I suffering "divitis"? (CSS especialist needed)

Jan 29 '10

It looks perfect. This should be taken as an example!

One symptom of "divitis" is when you see a list of <div>'s instead of using a <ul>.

Open Full Answer

Answer: How to use code blocks in HTML

⚫️ nothingness negates itself — Sat, 22 Jan 2022 22:31:36 +0000

why not re-style <code> with that class name instead of introducing <div>-itis 🚬😐?

answer re: How to use code blocks in HTML

Apr 30 '12

You probably want to do it in cascading style sheets (CSS). Create some CSS with the look you want, and things marked as <code> should take on that appearance. For example:

<html>
<head>
<style type="text/css">
code { background-color: gray; color: blue; }
</style>
</head>
<body>
<p>Some code:</p>
<code>My

…

Open Full Answer

add

⚫️ nothingness negates itself — Thu, 23 Dec 2021 13:29:25 +0000

[ ] tmux and tmux-plugins (https://github.com/tmux-plugins/list),
[ ] lazydocker,
[ ] todo.txt,
[ ] ack,
[ ] html-xml-utils,
[ ] unified-alps,
[ ] stoplight,
[ ] some validators[0],
[ ] alder (https://github.com/aweary/alder),
[ ] tig,
[ ] vim_cubed,
[ ] fzf and fd (https://github.com/junegunn/fzf https://mike.place/2017/fzf-fd/),
[ ] vim-seek,
[ ] vim-surround,
[ ] gti,
[ ] httrack,
[ ] lynx,
[ ] links,
[ ] urlview,
[ ] irssi,
[ ] newsboat,
[ ] ranger,
[ ] basics and workflows1,
[ ] diceware and blackjack or dining philosophers or byzantine generals?,
[ ] mutt,
[ ] cmus,
[ ] frotz (http://www.ifarchive.org/indexes/if-archive.html),
[ ] cygwin (https://blog.miguelgrinberg.com/post/web-development-on-windows-does-not-need-to-suck),
[ ] yeoman/yo,
[ ] yUML (e.g., yEd2kingly),
[ ] gruntjs,
[ ] gulpjs,
[ ] pm2,
[ ] nodemon,
[ ] almond/r.js,
[ ] docker-compose,
[ ] wp-cli,
[ ] ng (angularAMD, https://angular.io/guide/testing-code-coverage, etc.),
[ ] sirv (https://www.npmjs.com/package/sirv-cli),
[ ] surge.sh,
[ ] heroku,
[ ] netlify?,
[ ] storybook?,
[ ] node-red?,
[ ] npx,
[ ] npm (e.g., > $(npm run | percol)[3]),
[ ] mongod,
[ ] protractor,
[ ] cucumber,
[ ] cypress,
[ ] jest (hydration),
[ ] karma,
[ ] glances,
[ ] django,
[ ] tornado (https://www.tornadoweb.org/en/stable/options.html),
[ ] nginx,
[ ] apache,
[ ] owasp zap (https://www.zaproxy.org/docs/desktop/cmdline/),
[ ] ps,
[ ] ghostscript,
[ ] magick mogrify -resize NN% file.png,
[ ] convert,
[ ] brew,
[ ] curses (https://github.com/thobbs/multitail-curses),
[ ] calcurse (https://opensource.com/article/18/10/calcurse),
[ ] etcd,
[ ] clusterluck,
[ ] pandoc (specifically slideshow building),
[ ] openchain,
[ ] holochain (zomes),
[ ] handshake wallets,
[ ] nix (https://nixos.wiki/wiki/Nix_Installation_Guide),
[ ] zsh,
[ ] fish shell,
[ ] jsdoc,
[ ] css-specificity,
[ ] jekyll (https://pmarsceill.github.io/just-the-docs/#getting-started),
[ ] gem,
[ ] ctags,
[ ] mosh,
[ ] iptables,
[ ] winston (https://github.com/winstonjs/winston/tree/2.x#using-winston-in-a-cli-tool),
[ ] wiredep (https://github.com/taptapship/wiredep-cli),
[ ] webpack (is this zuckerbug's?),
[ ] qemu,
[ ] cli's for load balancers, facades, circuit breakers, gateways, etc.,
[ ] ionic (capacitor),
[ ] android studio,
[ ] consul,
[ ] keyware cli to cache invalidate semantic keyed links for MRUs,
[ ] etc.2

[0] , lighthouse, or

[3] aliases: run, rum, urn

if you aren't developing RESTful systems, you are historically and semantically NOT doing web development

⚫️ nothingness negates itself — Sun, 15 Nov 2020 14:35:55 +0000

please, you have to stop wasting my time with your opinion that i "just want to be right," especially if you don't actually know the circumstances around fielding's work.

you are in fact shitting on his life's work, because you don't actually read timbl, amundsen or any of them.

just like with black issues, you want to have opinions and be "respected" about stuff you have not done any due dilligence in.

you literally have a search engine right in front of you, and you think i am sharing just my "dogmatic" opinion.

no, i think there is a different issue as to why you're so focused on tone policing and respectability politics.

given the state of the world and me being black, come the fuck on. read the room, you are all striking out in more ways than just bastardizing and misrepresenting REST and the web itself, more concerned with white-knighting and gatekeeping. you didn't even engage REST, and i am trying to tear down these gates.

[UPDATE]: "A data format SHOULD incorporate hypertext links if hypertext is the expected user interface paradigm." https://www.w3.org/TR/webarch/#hypertext

if you are not putting hyperlinks in your JSON response, you are engaging in BAD PRACTICE and not developing SEMANTIC WEB based on LINKED DATA

Hypernames

⚫️ nothingness negates itself — Tue, 27 Oct 2020 03:53:58 +0000

Names usually point us to persons, places or things, so we learn, by the age of 3 or 4, maybe even younger. Later we learn that names apply to many other kinds of things: events, decisions, holes, spaces, directions, ideas, none of which technically are "persons", "places" or "things", per se. And yet, it is the purpose of a name to cover them all, to do them justice, and to lead us, presumably to them, however it is they are to be approach or engaged either spatio-temporally or intellectually.

So we have all kinds of names as well, if not more than the previous set of kinds of things, for which we then need new kinds of names for our kinds of names for our kinds of whatevers which happen to, as we might expect, carry on differentiating in their various and copious ways. Of course, there are simple names like "John" but also there are names like "Yu" or "AdapterFactoryMessageContainerFormatterSingletonFactor" or even "127.0.0.1" or "OpenPGP.v3-asdf". It's also obviously conceivable that a name can only be its true meaning if it is written in a certain color or if it is uttered only, never written. The list of criteria for a name is endless, truly. And yet the list of kinds of things also seems endless — which is bigger, the list of names or the list of kinds of things?

They certainly pick out things in the world, but why do these special symbols or characters do so in just the way they do, whereas non-special characters do not? What really is so different from a E and a ℇ or ∃, well, they were all introduced at different times, by different persons, probably. Something about their form and style carried along with the fact of their origination. And yet, they all mean very much different things, or can at any rate, and sometimes they can be used to say the same thing as one would as if they were all interchangeable. So the rules seem to emerge out of meaning thus and so in just the way one does, as often as one does, and apparently these symbols, often enough, are successful at reflecting the models of that fact of reality as it was then and conceivably re-portrayable in the future, given the meanings of words stick around, as it were, to how things are going on with us. The environment certainly also seems to play a role, in re-enforcing these singular multiples, but how might we determine their fit in the semiotic system-theoretic model of hypermedia communication?

Introducing Domain-driven Hypermedia-oriented Design (DHD)

⚫️ nothingness negates itself — Mon, 19 Oct 2020 04:27:38 +0000

Or “Development”? Whatever a developer chooses to take from this post, it may be applied to development per se, in some areas, just a little? Who’s to say? It’s a well-charted territory: Mike Amundsen (BDFL) already has developed and architected many rigorous and swaggerly demonstrations of the much feared “generic web client”, wherein our understanding is brought to discuss the requirements for both a server too. His book Building Hypermedia APIs with HTML5 and Node kickstarted a campaign, really, of a general style and focus of writing software that is explicit, scientific, testable, highly evolvable and modular: but hypermedia-oriented. Of course, the “first issues” of his “api-starter” repository might be to add Yeoman templates. What might they look like, for Data (fixtures, mocks, etc. directory under “support” in DDD) or Resources (are these not “apps” in DDD?)? What reasons might we have for choosing this configuration over that in our template patterns: is it to produce “pages”, web page elements, native app components, content-management system paradigms have many “widget” and “structural” representational Data Types (message models?); — does it, the response, need schema.org trappings and properties?

Hypermedia Made Easy. OSLC Fest. Amundsen, Mike. 05-2020.

Amundsen asks us to think in terms of “actions” (see schema.org/Action, which should probably be a store house for all the representation templates Amundsen has envisioned or which we could add) and “properties” when problem solving, less “data” or even “resource”:

“Your data model is not your object model is not your resource model is not your affordance model” (Mike Amundsen. 2016).

Developers may find Amundsen’s existing code repositories fruitful and fun to deploy, as he also produces YouTube videos guiding new developers and chronicling his journey, thoughts, patterns and inventions for hypermedia-orientation, in general. His most recent book (Design and Build Great Web APIs. Nov 2019.), as of the time of this writing, covers a lot of the server-side considerations: testing, deploying, shutting down, evolving, continuous integration, etc. of the hypermedia orientation. (I’ll be using that term a lot, basically to distinguish thinking that is RESTful versus what is so-called-REST. It’s not really up for debate anymore: if you’re not putting discoverable links in your responses as continuations of your application state, your API is not RESTful, and likely undermines the main goal REST set out to achieve and enable for further extension, refinement, advancement, etc.) Here, I would like to focus on what seems like a necessary intersection between domain-driven design and hypermedia-oriented design (or at any rate, the best examples of them that I could reproduce myself or find; hence, the mention of Amundsen, but there are others who focus on the front end, like angular-hy-res, or like himself, HAL modules and apiary, etc. exist). Few, however, have achieved the perfection in implementation of the idea as Amundsen, as his “starter” is more like an environment in which to work at the data and object levels, but also templating of patterns of Data in “representors” (representation templates). The primary “invention” which I am introducing, is perhaps a bit of a bit. Maybe not, in any event, since hypermedia is woefully absent on our internets as a widely-deployed thing, I wanted first to make a prediction: of how hypermedia relates to a kind of “civilizational index” if you will. Why should we need “another X”, even if it has been around for N years? What do “domains” and “orientation” have to do with the failures of internet campaign sites the promise to end political regimes (do any of them ever really do that?) or of developers' promises to turn code into literal freedom (through markets or whatever). Many have these ideas were conceived with adaptations, extensions and refinements to REST that no one ever talks about. They show you how to implement some CRUD, title their article “REST dies by the infinite glory of GraphQL” then promise that if it’s not your keys it’s not your bitcoin only ever if it’s not your money if you’re not spending it, or something.

Objects are dead; long-live the Resource! Or —

[ See codepen: https://codepen.io/nerdfiles/pen/oNLxVpR ] My invention is something like Margaret Runchey’s (Model of Everything patent), or at any rate, what I thought she was going on about: use the [rel] and the [class] expressions within the response as a generic input for formal input verification of a virtual state machine. What does this mean? You can representation pretty much anything in the class and relation space of a reason, and yet both in some way bring about more HTTP requests: CSS triggers background images and imports, etc., relations in HTML, depending on their name, do browser-specific things and other times not. Most IANA relations aren’t processed. But yet, we can pass all kinds of “syntax” into these attributes to which “on-demand” behaviors occur: we can lazily load them, transclude them, preload, prefetch, etc.

So it isn’t so much an invention but a challenge, an opportunity and a proposal: use link relation and CSS class to express transitions in the “ubiquitous language” of domain-driven design, as the “role” is next to follow in terms of WAI-ARIA. Make link relations for roles, like widgets and structures; make link relations for different CSS styles: make that “dark mode” setting itself a “link relation”, etc. How would you express that link relation? “alternate stylesheet”? Kind of boring. In any case, it’ll probably be a very clever link in a “native app” or an SPA, so how it is implemented may look anything but like a link: it might be an iPhone radio button toggle that fires an HTTP request on “true” for some object that was stored locally, etc.

I want to know the “name” we’d give for a “dark mode” link relation, and which resources would it appear on: would my “hamburger menu” be discoverable via only my API resources: using “up”, “prev”, even “back”, etc.? “settings/dark-mode”? Or just “dark-mode”: why does it need to be a link relation? Well, I want it available strictly via API, but on what resource? Is it itself a resource? /api/user/me/settings/dark-mode/true?

But how would I find it situation in the “library” that is your API namespace? Users and Products and all that, like Services, are usually bottom floor. Upper level ontologies have things like “Events” and “Types” and “Proposition”. We’re not asking for something as heady or as garden variety: tags, lists, menus, etc. are all covered by ARIA. could an API tell me all its “menus”? Could an API itself have an actual help menu? Like if I asked: /api/help/, as opposed to “login”. What would “help” represent? A CLI, a manpage, Wal-mart’s customer service number in a linkless JSON response?

So with hope I have dulled you with enough meandering questions so as to prime you to be a brutal in your critique and analysis as possible for this concept map I present, for it may even be foolishly combined at the outset!

First draft, file (rectangles) and folder (rhombuses) architecture: combining Domain-driven Design and Hypermedia-oriented Design

((Maybe use PASETO for authz and Firestore instead of RTDB? add any number of “databases”; write your own, whatever. I may have to write the implementation of PASETO to Passport.))

Other ideas: non-standard link relations, ASCII-like CSS class names

Imagine declaring relations in YUML:

<link rel="[server]-uploads->[client]" 
      href="https://example.com/do-something" />

or set up a CSS framework that parses YUML as CSS class names and does something smart in CSS with grids or flex, pseudo elements and other style properties.

[Originally published at medium.com.]

listen, web developer!

⚫️ nothingness negates itself — Sun, 11 Oct 2020 16:43:27 +0000

if the developer is not putting links in their JSON or XML response, they are not doing web development! it's that simple!

one philosophical decision, or perhaps ontological commitment, implicit to the definition of the web is that links are distributed; the web is fundamentally a distributed hypermedia application. it runs on port 80. links are distributed throughout its territory, notably inside of hypermedia. often, most often, hypermedia is served at some URL, like .../kitten.jpg (notice the file extension). why not: .../kitten/? well, usually because achieving this technically can be politically and technically difficult within an organization. nevertheless, it is obtainable and consistent with the terms of semantic web.

your JSON response could also be served as .../kitten.json but you usually don't, it's usually prefigured into an API somewhere; let alone adding links is a non-trivial task within maybe API frameworks, like even ExpressJS, HapiJS, LoopBack, and so on. so usually the prototypical example response is something like this:

GET ./kitten.jpg
<some jpeg that is text-like>

and:

GET ./kitten/
{
  "name": "morton"
}

but all hypermedia requires is embedding links in the HTTP response payload (hypermedia control can be extricated from REST, but that leaves us to wonder: what was the point of REST? well, it's first use-case is distributed control through hypermedia!), the entire raison d'etre of ReST is the following:

GET ./kitten.jpg
  <ul>
    <li><a rel="link-relation-type" href="/#state-machine-route?continuation-token={%= cont_token %}">State Machine Route</a></li>
  </ul>
  ...
  rest of the jpeg

and for application/json... subtypes:

{
  "name": "morton",
  "links": [
    {
      "rel": "{% state || 'link-relation-type' %}",
      "href": "{macroForBaseUrlReplacement}/#state-machine-route?continuation-token={%= cont_token %}"
    }
  ]
}

so now the client can navigation and discover "links" conceived through the [rel] attribute. think of baruch spinoza's "order and connection" of ideas and things: these [rel]s are the events, whether relations or decisions, of the state machine, expressed in HTTP Verb Requests like GET, PUT, etc. and resolve into HTTP Status Responses (if you're familiar with Express, etc.). one could say that POST, e.g., is not a "relation" but rather a decision, so it has no place in the list of [rel]s. i would argument that an alias can be constructed that is a link relation that maps to all the HTTP Verbs. so we get:

GET /kitten.jpg (or /kitten/; or /kitten.json)

{
  "links": [
    {
      "href": "http://example.com",
      "rel": "create",
      "tags": "...",
      "method": "POST",
      "fields": [
        "..."
      ]
    }
  ]
}

we get an HTTP 200. one question is what that response should look like for a 200 versus, say, a 201 given we're looking for a "kitten". which links should be available, and why? is the kitten in a grocery store? is it being purchased in a shop? what is the background of the resource model? this will determine the "syntax of the affordance" in the resource served. the client will do "the right thing", presumably, when it discovers the link and integrates its business into the grander schema of the internet of things.

but what other schemas are there? one line in particular is relevant:

      ...
      "rel": "create",
      ...

in the HTML into which it is given, it will likely be rendered so:

  <a rel="create" ...>...</a>

but really, it could be rendered anywhere:

<div uri:header="create" ...>
  ...
</div>

in which case, there will be JavaScript that is doing something Smart, Fun, Sexy and Cool (and presumably Perceivably, Operably, Understandably and Robustly); DOM updates, traversals and manipulations and all.

however, these are naming opportunities we're overlooking, for "create" could be anything, really:

  open
  version
  v1
  create.v1
  create:partOf
  go/north
  play
  replay
  update
  continue
  next
  continuation
  narration
  action
  potentialAction
  tradeAction
  O-panel__header--active
  rgb(--(...),--var(...),99)
  library/**/shelves/createdAd
  ∀x(Fx&¬G)
  m/5nYUWL0hAWy0Hw4T33XpnTnf0WQ7eOgCBQJUpMZs8=
  127.0.0.1/login

you get the idea (link relations exist: https://www.iana.org/assignments/link-relations/link-relations.xhtml, http://microformats.org/wiki/existing-rel-values, https://schema.org/SoftwareApplication): many different ways to express the interstructural matters of architectural style in a semiotic plane of consistency.

margaret runchey envisions a similar idea back in 2001 or earlier, of link relations as transaction identifiers owning people as data, as it were, as such "establishing a symbolic identity by formalizing referential relationship between a resource event (you) and an identifier": https://patents.google.com/patent/US7774388B1/en

it's data that, at the most, owns other data. which is presupposed as sensible and true in most Western ontologies, to some extent: a dog owns it own hair, surely.

"... there is also a built-in internal link through Unitary Integrated Ontology to predicate logic constructions. ... UR-URL ..." (Ibid.) and so on.

at any rate, what DDD does in infrastructure, Amundsen does in "data.js" in his starter, or at least explicitly: infra incorporates domains, so models are given living data, their data types are wedded to repositories, which i believe should exist in infrastructure at its base. the modules aspect, in interfaces like HTTP, is where DDD and HOD (hypermedia-oriented design) make first contact.

i'm reminded of a question in the philosophy corridors of w3c: "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/) it haunts me today. could a state machine use such a "memory" of reasoners housed in the web (add "memories", but also "apologies" and "guesses" (see CALM)? like an archive.org of publically, biblically accessible links to results of all propositional knowledge. what if we switch our conceptual focus to probabilistic knowledge (Sarah Moss): how will we achieve new results for MCMC algorithms claiming mathematical forms of novel inner structural and hyperdimensional complexity. could such an engine find your car keys? probably. it'd be a link in a Resource Directory (CoAP/CoRE) in your programmable home. in any event, it'll be programmable through semantic web, namely timbl's invention: Linked Data. if it is raining and the key is outside and Smith has ten coins in his pocket, etc. (see Gettier) so perhaps these reasoners would fumble, in which case we introduce the concept of "anaphora"; Smith and Jones get their own indexicalized non-representational pronoun meaning tags "he_sub(jones)". the Gettier problem vanished in our syntax, since intuitively we do not think that Smith thinks he_sub(smith) will get the job. why should Gettier get to couch in a conversational or casual pronoun embedding rule that loses, conveniently, tracking of pronoun veridicality exactly necessary for his argument to be "successful", when Sebastian Roedl formalizes explicitly pronoun use in symbolic relations structured inherently to joint spontaneous knowledge in his paper "You and I"? is it something we commonly "translate away" when converting sentences like "S has ten coins in their pocket"? does the gettier problem hold if jones and smith are a-gender? probably. if they are robots or epistemic agents or things of any sort for all sorts of language, in every language, because the logic rules gettier mentions and the one i am calling out here that he couches in are always processed one way within a socio-cultural mileu? probably not. but i digress.

if the web is a "virtual state machine" as Roy Fielding suggests, try yEd2Kingly: https://github.com/brucou/yed2Kingly#examples to build out your RESTful hypermedia systems according to Mike Amundsen's DARRT: https://github.com/mamund/api-starter/blob/master/darrt/. put hypermedia controls in your images and serve Winamp media players or cryptowallets inside them. give them voice commands, via DOM development, so now images can be served on simple web hosts and intercommunicate with APIs that respond to those voice commands over whatever host device is serving the media, given whatever host capabilities that media is reactively written to support. now the media can crawl about, through people sharing it, can report back interactions to a server, true, but if it has a cryptowallet to which it is passing continuation_tokens, then the requestions can be made transactions with eventual consistency and disorderly programming via (Bloom/Bud and reasoning according to CALM: https://speakerdeck.com/jhellerstein/the-calm-theorem-positive-directions-for-distributed-computing)

Todo list combining CLI and HATEOAS

⚫️ nothingness negates itself — Fri, 09 Oct 2020 19:41:54 +0000

basically:

app.get('/notes', (req, res) => {
  const rawNotesList = fs.readFileSync('../cli/notes.json', {encoding: 'utf8', flag: 'r'});
  const parsedNotesList = JSON.parse(rawNotesList);
  const links = [
    {
      rel: ["self"],
      href: [baseUrl, '/notes'].join('')
    }
  ];

  const actions = [
    {
      class: "add-note",
      href: [baseUrl, '/notes'].join(''),
      method: 'POST',
      fields: [
        {
          name: "command",
          type: "string"
        },
        {
          name: "content",
          type: "string"
        }
      ]
    }
  ];

  const responseWithControlData = {
    class: "note",
    ...parsedNotesList,
    links: links,
    actions: actions

  };

  res.json(responseWithControlData);
});

and:

app.post('/notes', (req, res) => {

  const body = req.body;

  if (!body.command.includes('add')) {
    return res.status(400).json({
      status: 'failed to add content', 
      content: body.content
    });
  }

  const cliCapture = new CliCapture({
    notesPath: './notes.json',
    command: body.command,
    content: body.content
  });

  res.json({
    status: 'added from server'
  });

});

We could analogize this CoAP/CoRE and Amundsen's DARRT approach: anything really can substitute for "CliCapture" and wherever fs is available, we can expand its capabilities with a resource directory mapping to HTTP (https://github.com/JelmerT/coap-rd/blob/master/requesthandlers.js#L82) with transitions:

See https://github.com/nerdfiles/notes-cli/blob/master/cli/server/index.js#L19-L56 and https://github.com/nerdfiles/notes-cli/blob/master/cli/server/index.js#L69-L73

CALM RESTful ROCA style with AngularJS

⚫️ nothingness negates itself — Wed, 07 Oct 2020 20:25:13 +0000

link dump. that's it (sharted 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 https://speakerdeck.com/jhellerstein/the-calm-theorem-positive-directions-for-distributed-computing?slide=45
hypermedia-oriented design (http://www.w3.org/2011/10/integration-workshop/p/hypermedia-oriented-design.pdf), richardson maturity design model, hypermedia view-based design, hypermedia modeling
segmented discourse representation theory (sdrt) model http://homepages.inf.ed.ac.uk/alex/papers/iwcs4.pdf
odrl model https://www.w3.org/TR/odrl-model/#infoModel
wai-aria model https://www.w3.org/WAI/PF/aria/roles
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
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)
web sequence diagrams https://www.websequencediagrams.com/
html is a programming language https://mortoray.com/2019/02/11/of-course-html-is-a-programming-language/?unapproved=107123&moderation-hash=e319816e50ae9ded3fa797491957fe94#comment-107123
microformats http://microformats.org/wiki/existing-rel-values
link relations https://www.iana.org/assignments/link-relations/link-relations.xhtml
json schema tool https://www.jsonschema.net
quicktype https://app.quicktype.io/
css selectors https://frontend30.com/css-selectors-cheatsheet/
flex help https://flexbox.help/
https://github.com/niqdev/angular-q-extras developers may wish to use ionic v4 (v1.3.3?, but install ionic@4 , etc.).
gist https://www.semanticarts.com/gist/
bitemporal data https://en.wikipedia.org/wiki/Bitemporal_Modeling
cqrs https://github.com/KABA-CCEAC/angular.CQRS/ (https://itnext.io/1-year-of-event-sourcing-and-cqrs-fb9033ccd1c6)
organic-css http://krasimir.github.io/organic-css/ (use with Atomic BEM)

figure 1:

different roles whose logics imply representational application controls expressible in hypermedia (SVG, etc.)