Guiding principles
From Pelennor
The guiding principles of Pelennor are the foundation of our technological vision. They should be seen as simple, high-level concepts with dramatic ramifications. Compare to, for example, the famous [Three Laws of Robotics]. These are our "laws" regarding how software should be designed -- with humans always in mind!
Principles for human interaction
Computers should "disappear"
Computers should become transparent to everyday life and should not require frequent thought. Technology should shape around our lives, not vice versa! Today, most computing involves a machine that we hold or sit down to use. In the future, computing will become a ubiquitous resource that follows us and somewhat invisibly makes life easier. Obviously, we will still be aware of the hardware, but we will never have to fuss with it. Computing should feel like a natural extension of our intellect, as a bicycle feels like a natural extension of one's body, after years of riding.
All human interfaces must be intuitive
If a user is sufficiently knowledgeable in a given domain, they should not require instruction on how to use computer interfaces related to that domain. This principle does not discount the inherent learning curve of a new work environment, but it does imply that learning the technology involved should be entirely natural and intuitive. A new user should be able to become productive without reading manuals, asking questions, or making mistakes in the process. Changes to a user interface should not even require users to be notified, let alone attend meetings or training classes!
Make no human interface assumptions
Human interfaces should be dynamically defined during use, considering many factors: input/output device availability, user preferences, physical environment, privacy needs, current task, etc. An interface that is convenient while sitting at a desk is probably not the right interface for a noisy manufacturing floor or a doctor in the middle of surgery. Likewise, an interface convenient on a large, high resolution projected screen is dramatically different than one suitable for a wristwatch, even though the data may be the same!
What You See Is What You Need (WYSIWYN)
People have a rather low input "bandwidth" and are easily overwhelmed with information. Software must be designed to give people only what they need at a particular time and place. This applies to both interface complexity and the amount of raw information presented at one time. (Of course, this should also be an individual preference.) The WYSIWYN principle helps computing become less of a distraction and thus further "disappear."
Minimize conscious human interaction
We should always strive to bother the user as little as possible. This includes, for example, making simple decisions without asking and suppressing alerts that are not important enough to warrant attention at the moment. As software evolves, human-computer interaction should eventually fall into two categories: executive decisions and creative processes.
All data can be made writable or annotated
Even though a user may not be allowed to publish data to a trusted source, they must be able to modify and annotate this data for their own use, as easily as if they had publishing rights. Unofficial data will then be stored in their personal repository, unless publish rights are granted in the future. This is similar in concept to today's web "mash-ups" or web browser plug-ins that modify page contents for local display.
Data types must never limit expression
Traditional software boxes users into a narrow set of data types that they may work with at a given time. Forms-based relational database applications and personal information managers are perhaps the most rigid examples. Even when custom data is allowed, it is usually constrained to a handful of types, and changes affect the whole application rather than individual records.
Discourage deletion
While users may certainly delete information from view, we should generally discourage the permanent physical deletion of data. See Never delete
Eliminate manual data shuffling
Any time a user must import or export data formats, manage files and directories, create backup copies, or install software, they are engaged in manual data shuffling. All of these tasks are unfortunate artifacts of today's aging software designs.
Principles for sustainable software development
Sustainable development is an economic equilibrium whereby progress continues or accelerates without a corresponding increase in the rate of resource consumption or an exhaustion thereof. In computer software, we want to continue adding functionality without needing more labor to manage it's complexity. We also desire to eliminate common reasons for developer "burn-out," which cause many to dislike their jobs or even leave the field.
Small is beautiful
Aim for perfection in small, re-usable components. The goal is to keep learning barriers low, focus quality control, encourage sharing, and promote effective self-management for individual developers. This might be dubbed the "wiki effect" - contribution is so convenient that it becomes self-motivating and self-regulating. At the same time, most contributions are so small that it makes little sense to keep them private or proprietary. Unlike the enormous, intricate, monolithic software in popular use today, there is far more room for open-source-style development in this environment.
Favor aggregation
Aggregate small components to achieve sophisticated functionality.
The network is the computer
Today's software and electronic gadgets create islands of information and islands of functionality. They also create an enormous amount of duplicate developer effort and many inconsistency issues for users. Standardization of the World Wide Web has made some progress, but has ultimately only moved the problem elsewhere. (from individual desktop PCs to individual web server farms) Realizing the original "network is the computer" dream means transforming every device into a member of a vast distributed web of semantic data and services. With such a network at developers' disposal, far less wheel re-inventing and custom implementation will be necessary.
Avoid the boring work
Most software developers should be involved with neither very-low-level details, which are abstracted, nor very-high-level details, which are defined by users, generated at run-time, or managed by intelligent agents. The majority of work that remains is that which is truly useful: development of complex logic, algorithms, and business rules. Within this scope, there is still a broad range of tasks. Lower level components include pattern recognition engines and security frameworks; higher level components include UI workspaces for different environments and devices. (ie. components which render an abstract UI to various concrete implementations) However, the vast majority of development work will be "wiring up" existing components using mid-level tools and languages. (For example, logic that takes input from various raw and filtered sources and generates events to send to higher level UI components)
Make everyone a programmer
All but the least sophisticated users will be involved with some form of very-high-level programming. However, it will not look anything like working with traditional programming languages. Interfaces may include natural language parsing and graphical flow-charts where high-level logical components are wired together.
Principles for design efficiency
Make few assumptions about hardware capabilities
The simplest hardware is a device which can store a tiny amount of data and transmit and/or receive changes to that data over a network interface of any kind. A toggle light switch is conceptually our simplest device, a networked J-K latch. It holds one bit of state, transmits a one-bit message, receives a two-bit message, and is uniquely addressable.
Make few assumptions about hardware availability
Our network is extremely dynamic. Devices constantly come and go. Power states change frequently to conserve energy.
Centralization is dynamic
Centralization occurs naturally as a response to dynamic loads, routing, and service availability. We eschew the complexity, rigidity, and overhead of domain-based services and data stores.
Principles for security and privacy
Encrypt everything
Build networks of trust
Otherwise, you won't know who to trust.
Don't talk to strangers
Provide own customer profile
Communicate on a need-to-know basis
Anonymous broadcast traffic
(Be a beacon!) Just because you don't talk to strangers doesn't mean you can't listen to them anonymously. Some might even save your life, such as a wrecked vehicle warning you to stop to prevent a pile-up in the dense fog ahead.
