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.