A Meeting Agenda

Possibilities

  1. Activated Reports, Data Mining Results and Dashboards.
  2. Qualitative Metrics.
  3. Less expensive software development.
  4. Human and technology integration.

Implementation

  1. Corrects a mistake made 40 years ago.
  2. Characterization rather than categorization.
  3. New SDLC, Architecture and Business Needs and Opportunities.
  4. Most things can be done better.

Why Graphic User Interfaces are Hard

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.

Comparison Check Micro Language

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.

3D Linked List Micro Language

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
----------------------+------------------------------------------------------------------
ABCDEFGHIJKLMNOPQRSTUV|

Atrtribute Key:
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:

3dlink:OBVMUAJG:knit

The Business Talent Endeme Set

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.

  1. 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.
  2. 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
C. Creativity
D. Deduction
E. Emotional Intelligence
F. Financial Intelligence
G. Growing / Learning / Teaching
H. H-presence
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

Fuzzy Semantics

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.

Fuzzy Functions

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 Used for Combinations

Endemes can be used to store and process combinations of concepts.

COMBINATIONS
————
– 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?