PHILOSOPHY AND PRIORITIES

UMENU2 is a plain text outlining system that executes commands based on
selections off a hierarchical set of menus. 

* Speedy workflow
* Easily deployable
* Simple
* Discoverable

The preceding four phrases mean different things to different people,
so they'll be explained in the PRIORITY DEFINITIONS section of this
document. But first, here are some non-priorities:

* Pretty
* Fashionable
* "Suites"

# PRIORITY DEFINITIONS
One must be careful when stating priorities, because definitions vary
widely. Some folks think that the GNU GPL is a "freer" license than the
MIT, while others see it just the opposite.

## Speedy workflow
Speedy workflow means the user gets his work done faster. Most touch
typists agree that hitting a few keystrokes is much faster than using a
mouse. Assuming UMENU2 is instantiated by a quick and easy hotkey, a
touch typist can run a command four menus deep in less than two seconds.
Don't try that with a mouse interface.

UMENU2 might not be right for the hunt-and-peck typist, because he
wouldn't get the speed advantage of the keyboard.

For the touch-typist, UMENU2 is greased lightning. Without leaving home
position, the user can navigate 4 levels of menu to choose a program to
run. UMENU2 is faster than most other text menu systems, because unlike
them, it doesn't require you to press Enter in order to read each letter
you type in. It's fast.

## Easily deployable
Easy deployability means a lot of things to a lot of people. Some view
deployability as their distro's package manager installing the software,
completely working, with an apt-get or YUM or xbps-install command.
Although this definition might work for end users, it doesn't represent
the distro's view, because the distro must create such a package, and
many softwares make that very difficult.

Others think that easy deployability is a matter of an install script or
program. UMENU2's install_simple.sh script does that, but I recommend
against it. The cautious person wants to be in charge of each step of
installation, so that a well-meaning installation script doesn't do
harm.

Still others think of easy deployability as conforming to the UNIX
placement of files: Config in or under /etc, executables in /usr/bin or
/usr/local/bin, loadable libraries in or under /usr/lib, documentation
under /usr/share/doc, together with autoconf created 2000 line Makefile,
and dependencies on ten libraries, any one of which might require a
later version than your distro specifies. Although this scenario is
be best in some circumstances, it's not easy.

UMENU2's idea of easy deployment is to install a tree from a tarball,
run an executable from that tree, and wham, everything works. Uninstall
is as simple as removing that tree.

UMENU2 can be deployed with other directory structures, but even those
can be customized with a file manager and a few quick changes in
UMENU2's conf directory.

Speaking of configuration: No XML, no YAML, no JSON, no exotic outlines
or Windows-style two level key-value pair files, no database necessary.
All configuration of the program and the menu hierarchy is done in
directory trees in which leaf level nodes are key-value pairs in which
the filename is the key and its contents are the value. To facilitate
quick menu building, UMENU2 gives you newitem.py and newmenu.py, but the
fact is you can easily configure either the program or the menu
hierarchy from a file manager, or from a command prompt.

Most would agree that the king of all deployability impediments is
dependencies. Here's a list of UMENU2's dependencies:

* Linux or BSD
* Python 3 with its standard libraries

That's it. If you have Linux or BSD, and you have Python3, you can run
UMENU2.

## Simple
Definitions of simple differ. Some believe simplicity stops where the
keyboard begins, and those folks clearly aren't candidates for UMENU2.
Some view simplicity as a program's ability to guess their wierdest
thought processes and irrationalities and adapt to them. Once again,
that's not UMENU2: UMENU2 is completely determinate: It reacts
identically to identical user actions, every time. Its only use of state
is submenu navigation.

Beyond being simple to use, UMENU2 is simple to install, configure and
understand. It depends only on Linux/UNIX/BSD and Python3. Its program
and menu hierarchy are configured with key-value pairs consisting of
filename and file contents, in directory trees. Its executables consist
of about 1100 lines of Python.

UMENU2 requires no special tools to administer. The menu systems can be
created and updated from the command prompt or a file manager. UMENU2
does give you two programs, newmenu.py and newitem.py, to make menu
creation go faster, but these are auxiliary, not required.

If you know the basics of directory and file hierarchies, you know
can learn exactly what goes on inside UMENU2 by looking at its tree.

## Discoverable
UMENU2 is completely determinate. As long as you don't change the menu
hierarchy, it always operates exactly the same way. In every menu, you
know all the choices you have. Like every other hierarchical menu
system, if you've designed your menu hierarchy well, with well grouped
choices and self explanetory titles, your next move is easily
discoverable.

# NON-PRIORITIES
As mentioned before, UMENU2's non-priorities are:

* Pretty
* Fashionable
* "Suites"

There's a cost for pretty colors, fonts, transparency, layouts, and the
like. It's a cost I don't want to pay as UMENU2's developer, nor as its
user. UMENU2 isn't GUI, because GUI programming is much more involved,
requiring much more CPU and RAM, and of course it precludes running in a
CLI-only environment.

Even Ncurses has a cost. It's big, and unless specially compiled, it
causes Valgrind to report memory leaks on your application. If you're
anything like me, you don't quit until Valgrind reports no leaks, and
that's impossible on an app using a normally compiled Valgrind.

Then there's fashionable: the "newer is better" crowd. The number one
objection to UMENU is its interface reminds them the video store their
parents used to frequent. But the fact is, it's lightning fast, it
easily installs on any Linux computer, and it lightspeeds your workflow.
Once upon a time, frames were the "new thing" in web design. We all saw
how well that turned out. UMENU2 isn't for followers of fashion: They'd
be better served with Ubuntu's Unity.

You've gotta love these "suites", in which every program is
interdependent with every other program. LibreOffice is one of the less
entanged. From there we go to wired together messes like KDE, Gnome and
Unity. UMENU2 minds its own business. Nothing needs to know about it,
and all it needs to know outside itself is the commands to start
programs it invokes.

# SUMMARY
If your priority is swift, keyboard controled workflow from lightweight
software that's easily deployed and understood, UMENU2 is what you need.
Those prioritizing pretty, cool, fashionable, and gratuitous
interoperability should probably look elsewhere for an application
launcher.


/* vim: set ai tw=72: */
