Future of human computer interaction
See also: User interfaces for gem-gum on-chip nanofactories
Contents
Generally desirable targets
- Deveusers: Rift between "end users" and software developers vanishing or at least drastically shrinking.
- Multirepresentationality: Allowing for each problem/data/code the best matching visualizations (plural)
- Data/code visualizations always stay in sync
- Data/code visualizations start out and remain human readable
No blindly manipulating symbols. Neither blind in time nor blind in space.
- Time: Liveness: (no temporal delay between user input and computer output)
- Space: Direct manipulation: (no need for manipulation of code for things easier manipulated by other means like graphics)
- Programming feeling enjoyable like a domino puzzle. See: Typed holes
- Better organisation and discoverability of data (data wikis replacing tree based file systems)
Necessities to reach these targets
- DataIsCodeIsData: Treating data and code the very same way. Code as data & data as code.
- Contentaddressedness: Keeping data/code in immutable content addressed databases.
- Projectionality: Having visualizations being projections from that database onto various desired representations.
- Languagebasedness: Rather than scripting the UI the base layer is the language and the UI just various projections.
- Homoiconicity (more on that below)
- Formal edit calculus and diffing
Why is there so much talk about code when this page is about human computer interaction?
Well, e.g. Editing vector graphics is a sequence of edit operations. As pretty much every work on a computer is.
It's a kind of program. Albeit a very trivial one.
Metadata must not receive special status
Extremely important:
Metadata must not be treated separately outside the data=code projectional UI-system.
Metatdata can include things like e.g.:
- State of progressive disclosure (what is shown)
- Placements of elements (e.g. windows) (where is it shown)
- Zoomlevels of elements (how big is it shown)
- Ordering of on screen elements, applied styles, ...
Especially important metatdata is the sequences of edit actions.
This includes both manual UI edits & automated edits too.
- (1) reversible code diffing (formal edit calculus = code = immutable data too!!)
- (2) reversible data diffing (neither more general nor more special than code diffing)
- Data is a special kind of code. Code that contains data-carrying-datatypes.
- Code is a special kind of data. Data that is data-carrying-datatypes-containing-code
E.g. in a spreadsheet like live UI setting:
Editing a cell conceptually must not mean an in place update,
rather it must mean an invisible jump to an other spot in the immutable multiverse of possible UI states
And not even that. Whole edit histories themselves must too be such immutable spots in the codebase=database=filesystem.
This may sound like a pretty extreme standpoint.
But it is an absolutely and unconditionally necessity for true boundless composability and thus sacalability.
Pervasive immutability ...
Impure function ("functions" that potentially do different things when called again with exact same explicit parameters) must be
encapsulated away. Ideally banished like the now pretty much universally agreed as bad (since spaghetticode inducing) "goto" has been.
(wiki-TODO: Improve the ending.)
