User interfaces (UIs) are hard to work with.
- There is little standardization from interface to interface.
- There is no memory stored of the sequence of clicks and selections used to navigate.
- There are no iteration constructs.
- You can’t format the UI to make it easier to understand. The format is hard coded.
- Functions and parts of the application are hidden behind a series of menu and button selections so you don’t know what the UI can do.
- The meanings of the various UI widgets are hidden, usually you just have a single word or menu item word to go on. You can’t drill down to find out what something means.
- The wrong words often get used to label a widget.
- It is hard to keep your focus on what you are doing. Each delay after a click increases the chance of loss of focus, and there you sit trying to remember what you were doing.
- UI’s are very manual and prone to error.
- The context for the data shown is missing, as is the context for pages and buttons, especially when a menu is used to reach a page.
- You can not search for the functions of an application.
- You can not use the code/functionality in a UI for something else.
- You can not modify what a UI does to do what you need it to
- You can not use a UI to build This Stack.
Code is much easier to work with.
- You can modify the code, run it and see the results of the change.
- You can reformat the code to make it easier to read.
- Code is standardized for each computer language.
- You can set up iteration structures to repeat tedious tasks, rather than having to go through the same series of manual clicks over and over again.
- You can step through code to drill down into it and see what it means.
- Code has memory. The code does not change as you use it. You can go back and look at previous statements to see what it did and how you got to where you are.
- Code bases are searchable. You can search for the functions of an application.
- Code does what you tell it to.
- You can use the code/functionality in code for something else.
- You can modify what application code does to do what you need it to
- You can use code to build This Stack.
The possible solutions
- Make code usable as a UI – Perhaps expand the IDE into a code/application/use browser. Maybe everyone should be able to step through the applications they use.
- Make UIs more like code – Make UI’s reformatable, searchable, standardized, drill downable, iterable, relabelable, traceable, and contextable.
Learning a graphic user interface is like learning a whole new computer language. I’d rather learn the computer language because then at least I can do something useful with it.
I have been thinking more about micro languages based on endemes.
Here is a possible micro language for comparison check logic:
A. Above Above, Greater, Greater Than, Over
B. Below Below, Before, Less Than, Precedes
C. Changed Changed
D. Day,Date Day, Date
E. Equals Equals, Equal, Equal to
F. Finishes With FinishesWith, Ends with
G. Generalized Generalized, Soundex
H. Hour Hour
I. In List In list, Contains
J. Year Year
K. Kit Given, default, now, zero, blank
L. Like Like, Likeness, Levenschtein Matrix, Endeme match
M. Month Month
N. Not Not
O. Or Or
P. Present Present
Q. Quarter Quarter
R. In Range InRange
S. Starts With StartsWith
T. User Spec Customer specified
U. Union And
V. Week Week
You have to write a whole series of 'micro' programs to get
much done. You can separate the programs with commas.
Or you can use regular program logic in a program of some
standard language and run the micro programs from within it.
I built a system ages ago for creating, navigating, and deleting
linked list items in three dimensions.
/ / / /|
/ / / /|/|
| | | |/ /|
| | | | |/
| | | |/
This endeme set contains operations that navigate, and
manipulate a three dimensional linked list construction.
The way it works is this: Think of a cursor with a primary
and secondary direction, sort of like the letter 'L' in
which the primary direction is the long stroke of the L
and the secondary direction is the short stroke of the L.
Now think of all of the following operations as operating
in either the direction of the long or the short stroke or
in the case of a rotation in the tertiary direction which
is the rotation around the long stroke. Turns would be 90
degree changes of direction of the long stroke either into
or away from the direction of the short stroke. These
allowing movement, creation and destruction in 3 dimensions:
3d linked list operation endeme set:
ABCDEFGHIJKLMNOPQRSTUV|lt equiv. attributes label notes
A]C- J L |A. O..A . A 1 Attach Connect/Directed link
[B] |B. FMF . M 1 Back back up, opposite of Move forward
B[C] |C. C . C 1 Create Build Item
B[D] -U-|D. D . A 1 Detatch Unlink/Break link
-D[E] |E. E . C 1 Erase Delete item in the primary direction
[F] |F. TT . T 12 Flip reverse primary direction and secondary orientation
-B- [G] J -O |G. O..G . J Goto Goto(mark)/Jump
[H] -U-|H. H . J Home Root/Up/upper lefthand corner, primary right, secondary down
[I] |I. TDU . A 2 Isolate unlink in secondary diredtion
-B- [J]L- |J. O..J . A 1 Join Back link/Link from
[K] -ST- |K. O..K . V Kite Swap/Trade values
[L] |L. RRR . R 3 LeftRot Rotate Left 90 degrees
-F- [M] |M. F . M 1 Move Forward
[N] |N. TEU . C 2 Negate delete the item in the secondary direction
-M[O] |O. O . A J Orient Mark/not just a node but a position too
A- -G- [P]QS- |P. Q . V Put/Pull Query/Access/Get/Object retrieve/Push/Set/Store Object
-D-F- [Q]S- |Q. Q M 2 Quiet Sink/Fall/Decline
[R] |R. R . R 3 Rotate Rotate Right 90 degrees
[S] |S. RR . R 3 Spin
[T] |T. T . T 12 Turn turn the primary direction 90 degrees in the secondary direction
[U]|U. TTT . T 12 Unturn
-R- [V|V. TMU . M 2 Vault Rise
A)ttachment, C)reation, J)umping, M)ovement, T)urning, R)otating, V)alues
1)in primary direction, 2)in secondary direction, 3)in tertiary direction, 4)to orient mark
This is not just a 'reduced' instruction set but a 'used
only once' instruction set where each instruction can only
be used once in a 'program', for example the program below
called 'knit' which can be used repeatedly to zip two
linked lists together:
Here is the business talent endeme set. It is based on the idea that various kinds of intelligence are good for doing various kinds of work. can be used to hire, reassign job functions, reassign people, grow teams, address objectives, and train.
- When used to assign work, a different endeme gets built for each job function and each employee and they are matched up based on who matches which job functions best and which job functions are most important to have accomplished well and quickly.
- When used to grow teams and address objectives, an endeme is built using this set that best matches what is needed to accomplish the purpose of the team or the objective, and even if there are few job functions in the team related to that objective, someone is brought in that matches the overall objective.
Business Talent Endeme Set
A. Advocacy / Appearance
B. Bravery / Pressure
E. Emotional Intelligence
F. Financial Intelligence
G. Growing / Learning / Teaching
I. Inductive Reasoning / Diagnosis
J. J-physical Intelligence
K. Kinetic Intelligence
L. Language Use / Linguistic Intelligence
M. Mechanical Intelligence / Manual Dexterity
N. Navigation / Networking
O. Organizational Intelligence
P. Practicality / Expedience / Politics
Q. Q-recognition / Matching
R. Reason / Cause and Effect
S. Service / Help
T. Teamwork / Influence
U. Utility / Office Work
V. Visual Intelligence
Semantics and syntax seem to be a major distinction in computer language development. Semantics is the meaning of the keywords. Syntax is how they are put together in a program. I have been thinking of an endeme based language for a while. It would seem that the third level might be a semantic level and that the work with semantics at level 1 and 2 might be a bit out of the natural order. Semantics is the meaning of words and since words are information that go together to make sentences and since the organization of items is at level 4 with Knowledge Representation, then semantics would be at its natural level at level 3. So an endeme based language would be naturally focused on variable definitions of semantic data.
At levels 1 and 2, there is a tight coupling between the semantic keywords of a language and their function. Their function is very precise. And it has to be because perfect operations on data are the focus of level 2. If we build a language at level 3, semantic words will still likely have some sort of function, but it would theoretically be very imprecise. At the level of precise functions, things either work or they do not.
At level 3, functions/actions would have fuzzy results. Is there such a thing as a fuzzy function? What would a fuzzy function be like? The timing of individual functions might be different during different runs, The conditionals could provide fuzzy logic results. Operators might provide results with probability distributions rather than specific numbers. Other operators could provide qualitative results (endemes) rather than quantitative results. Iterators might run on different subsets of lists or in different orders on lists. Filters might be match weighting based rather than in or out based. Parameters might be there with a percentage on each rather than either there or not there. And creative operators would include randomization. maybe the most important fuzzy functions would be attached to whether something existed or not. When you work with activated fields this is an important concern.
When you work with active fields, each field is defined by an endeme. Each field has an endemeatic meaning defining what the field is. So unless the field’s endeme is an exact match for the field you are looking for using an endematic meaning, then its existence is in question. This may be the base distinction.
Endemes can be used to store and process combinations of concepts.
– Semantic Combinatorics: A system of building complex semantic concepts from ordered combinations of words each of which has a simpler semantic concept.
– En endeme set is a set of “concepts that can be combined”
– We find that it is better to have
“a small set of simple concepts that can be combined in many ways”
– Understanding Combinations: A remarkable feature of human thinking is our ability to understand new combinations of concepts. Can we get a computer to do this?