## In Brief
* Hardware control devices should be **as dumb as possible**: 
    * they tell the computer about e.g. if a slider was moved, or a knob turned, or a button or key pressed, **and nothing else**.
    * they display (via screens or [LED]()s) **only what they're told to display** (save possibly for a power [LED]() and a small
number of 'status [LED]()s, but **as much as possible should be under the host computer's control**: thus **Make Hardware Dumb And Software Defined**. That is: SoftwareDefinedHardware
* It should be possible to assign **any button** to **any action**, and have **any encoder/slider** control **any continuous parameter**: **Make Everything Addressable**.
* On the topic of MakeEverythingAddressable, we come to MakeEverythingScriptable. There is a need for a common language, and my suggestion here is Lua.
A 'universal scripting language' needs to be as compact and easily-embeddable as Lua, and not involve TooManyParentheses like e.g. Lisp/Scheme/Guile.
(Yes there is beauty in Lisp, but for connecting buttons and knobs to actions, we don't need it.)
    * Most actions can be specified using integers, floating point numbers, strings, and possibly arrays and dictionaries. Nothing more.
    * Every common scripting language has support for these (though some like Javascript make it hard to use integers as integers),
       so make everything addressable using something such as this.
    * The thing about MakeEverythingScriptable is that if it is ubiquitous, far more people will learn to use it, and expect it.
       As such, a the moment, scriptability is mostly the niche domain of nerds, geeks and power users. Scriptability needs
       to be brought to the masses.
* The user interface should communicate with the engine of the app in the same way scriptability does. Thus **anything
   that can be accomplished via the [UI]() can be accomplished via scripts or actions**. Forcing everything through the script/action core,
   though harder at first for the developer, later empowers the user to use their software to the fullest extent possible.
* Give the user all the precision they want, when they want it, and keep things tidied away at other times.
* Give the user as many options to control things as possible. For example, panning a document using a joystick/gamepad? *Just
   because you can doesn't mean you should*, but **make all things possible first, and then make the common cases
   as easy and accessible as possible**.

## So it boils down to
1. MakeEverythingAddressable
2. MakeEverythingPossible
3. AnythingCanControlAnything
4. MakeEverythingScriptable
5. SoftwareDefinedHardwareControls
That is what Hedgehog is all about.