Application Aesthetics - LeFreq/Singularity GitHub Wiki
On Zen Code, there are 8 points, in 4 crucibles, which encode all of the aesthetics of the computer and the programming enterprise. This page is going to try to apply them to the application, just like code. Everyone's code can be beautiful. You don't need ugly code and if you do, fix your hardware.
Your objects will be composed of many other objects, each doing some interesting thing and holding some state. Every object is an application, which means it must take in some data and output some data, transforming it in some interesting way. The data in can be filtered and data out can be decoratored.
Computers have no questions, so your application shouldn't ask them either. Presumably, as programmer of the application, you know what you're doing, so why ask questions? Just tell them.
I file this one under TightCoupling: you are keeping your app close to the machine, while the user stays close to the data.
Instead of:
- Play again Y/n?
- What is your name?
- Press ENTER to replay or Q to quit.
- Enter NAME:
Computers have limited memory and CPU resources, so why require typing or printing output excessively? Don't make your messages overly verbose or prose-like. The user can attempt to rise up to the level of the machine, too. The application programmer doesn't have to dumb themselves down to the user on everything.
This page is about how to make your applications conform to a certain look and feel so that people feel familiar with your application, and don't tread into personal territory of the application programmer's personality.
Personality has it's place, but when you're seeking integration with the corpus of all other code/apps, there is a certain convergence of aesthetic that can be gained.
Application names should be clear about what they do. ClotheYourData says to try to give it the best look you can that tells you as much as you can without getting gaudy. This is a special art.
LeaveItNaked If you have data to display, do it, but don't glamorize it by adding excessive noise.
Computers like order. Humans like simplicity, yet don't like losing control. There should be hints that there is more under the covers that cannot be rendered.
Apple computer tried the experiment that humans don't like having to know what's going on under the hood, yet this only works when everything is perfect. It has resulted in monolithic, never re-useable applications, who's data isn't universal enough to be shared. The computer is an unbounded resource of creativity, not just work. Let the balance be found by using little graphic hints, without words. These can be touched upon by the user to drill downward into the applications space and be customized.
SeparabilityOfDomains is another aesthetic: since computers can re-use common code and constructs, try to make applications which don't do anything that another application does. These different domains should be color-tagged in the 3D VISUALIZATION MODEL and conform to existing color codes by Library of Congress or TAG ontologies.
You application is composed of data from the computer's point of view, yet this is vastly different ontologically from the data that the user is making with your app. Instead of File menu options, you send your file to the app and it displays it. Closing the application, automatically saves the file in its last known state.
The computer has such a vast space of creation that it should be seen as infinite, just as math. This puts a big task upon the systems administrator and programmer to apply meaning to it all. Do not create more problems by adding superfluous visual noise or dialogs.
Mathematics uses domains, dimensionality, and number layout or concepts like "closed objects" within geometry to keep items separate. Try these.
The OS is designed to be useable with legacy systems with 1Mb of memory and 1Mhz CPU. The true master doesn't bend the computer to his will, but blends the will of the computer with her own -- the computer is perfect (or should be).
It's all data. The app is processing kilobytes or more of data. Your app is sending data to the user as a gateway from user to computer and vice versa, so make that data have meaning. Like the perfectly chosen word, without wasting the user`s or the computer`s time. A thousand bits is enough to address every piece of data in the universe. So why do you think you need so much?? Because you haven't mastered your universe. That's it.
Minimize Processing is an aesthetic, so that you aren't using complex graphics for communicating BUSY states (rotating wheels), but each object can be given a pixel or character cell that shows entry into its object code. This allows the user to adapt their behavior to the app, to some degree
Minimize Memory XXX less verbosity belongs here? Functionality tends to gravitate towards its perfect form, yet words and prose tend to be imprinted into users brains, becoming territorial. Words tend to be region-specific. Focus all of your power on ONE word, like a brand logo. Sometimes you have to make one up. If you aren't a PhD, don't do this without talking to one. They and poets have the leeway to make up words.
Unspoken in Zen Code, is the hidden aesthetic of uniformity: your application is being consistent as possible so the user doesn't have to decode idiosyncrasies. But think of uniformity in the way Nature makes all the leaves green, not like the military. To this end, applications should build on the GOOP as the way for data to interact with applications or to get information about them. So, for example, that you can send a file to your app using the >> operator. It will also respond to getstate requests from the outer OS. While many OSs suggest conformity to a menu bar and other items. This OS reduces it to the bare minimal data needed for the application to run and applies it fractally.
When one has ingested this bit of wisdom, one has mastered the OS.
XXXThis page is written in someone else's voice.XXX