Semantic interfaces

Graphical applications tend to focus on concrete representations of their UIs, restricting accessibility, extensibility, and interoperability, while GUI toolkits make even that rather hard to do well (see "Cross-platform GUI Toolkit Trainwreck", "Gui development is broken"). Some people stick to unixy tools, which reduce everything to text streams, but it's still much better in those aspects; others abuse web technologies or Emacs, which allow for different kinds of compromises; yet others experiment with semantic and/or declarative interfaces, about which this note is.


The general approach is to describe both input and output in a way that leaves some freedom to implementations – that is, focusing on semantics, or on the model, possibly providing some hints for concrete interfaces. Examples of those, as well as of related or potentially useful for it technologies, are below.

While it's a rather bad example in how it is used in practice, and rather restrictive by design, HTML 5 tries to rely on semantic markup, can be accompanied by RDFa, and CSS can be seen as a representation recommendation. And it's the most widely used one.
XMPP Data Forms
Form descriptions targeting thin clients.
An RDF display vocabulary, which provides hints on how to present RDF data.
Semantic forms
RDF-based form generators.
Plain RDF
Other combinations of XML, XSLT, RDF, CSS
Generic RDF browsers and editors can be used as well, XML with associated XSLT can suggest representations.
A generic FSM description language, apparently intended for voice interfaces. Seems handy, though those can be embedded into types/propositions as well (e.g., Idris ST).
swagger2 with Swagger UI
Haskell packages generating interfaces out of types: JSON with OpenAPI in case of Swagger, command-line options and DSV with usage strings in case of Coalpit. These allow to easily expose complex structures (and functions operating on those) to other programs and users, and can potentially be extended to use RDF, presentation hints, and so on, and would get considerably more descriptive with dependent types (see a somewhat related "Document templates" note).
My toy/prototype project
Doesn't even have a proper name, but still serves as an example: semantic and textual UI descriptions are read as input and rendered, user actions produce output.
DBMS interfaces
While most of the web applications seem to be little more than eye-candy and restrictive interfaces to databases, and there are generic interfaces to those, perhaps this is worth mentioning. But these are primarily about storage and retrieval, even though one can go crazy with stored procedures, views, and triggers.
Sequent calculus
A handy way to deal with propositions in general, and may be useful for zooming user interfaces.

The mentioned projects can be grouped into those focusing on fuzzy description logic, on intuitionistic logic, and the less generic, extensible, and/or semantic ones, which don't focus on a formal logic. Unsurprisingly, propositions are helpful to carry semantics.

An interface outline

Aiming exchange of propositions in different kinds of logic, perhaps UI should mostly deal with sequent calculus, while the program it communicates with would handle inference rules, read user-composed sequents, compose new ones. A loose analogy can be made with sequent calculus corresponding to a terminal, logic – to a shell, program – to streams of propositions (though probably in most cases it would be more handy to define custom inference rules in a program itself, perhaps plugging some kind of logic as a library), escape sequences – to rendering hints.

There's a bunch of nice opportunities for UI zomming with sequent calculus, and the system may be rather simple/minimal and generic with it. But a bit of experimentation is needed to see how usable it would be, and it may be just a fun thing to play with. The representation of those propositions would still be tricky though.