Principles for a thinking tool
Pen and paper are great tools for thinking, easy to pick up, but endlessly flexible. How can we make programming more like using pen and paper? How could we update these tools for the 21st century? Here are seven principles for a more human centered programming environment.
Low Floor, High Ceiling
Programming shouldn't require a lengthy setup process, and hours of ploughing through dense documentation to get started. Nor should we be stuck with oversimplified tools, that only allow us to deal with trivial cases. Instead, make sure that simple tasks are easy to accomplish, without limiting what can be accomplished. Programming should be "Low Floor, High Ceiling", having multiple entry points so it is accessible, but also give space for people to develop and explore more advanced territory.
Speak to people in their own language
As they say, there are only two hard things in Computer Science: cache invalidation and naming things. Most programming languages require names to be unique and a single word, and force you to remember and identify something by that name only. This isn't a problem of computer science, it's just bad interface design. Instead, use recognition over recall, use language that maps onto a users vocabulary and make things searchable by including documentation and synonyms. Most programming languages are based on english. This makes it inaccesible to the non-english speaking community. There is no reason why programming couldn't be multilingual.
Don't reduce complexity, make it managable
It is often said that programming is hard because of incidental complexity. But complexity isn't something that should be avoided at all costs. We can't solve complex problems with simple solutions. Humans are actuallly very good at dealing with complexity, when we have the right tools. Navigating a subway is a very complex task, but it is manageble because we have tools like subway maps, signs and timetables. These tools don't make the subway network any less complex, but they do make the complexity manageble by showing the relavent information in the right context. A programming is like navigating a subway, it's a lot easier if we have the right tools.
Build abstractions bottom-up, not top-down
Most programming languages let you create top-down abstractions. For example, describe an abstract class and then create an instance. This is very hard to do, because it requires a lot of upfront thinking. People tend to think from the concrete towards the abstract, not the other way around. Let a user describe something concrete and then deduce abstractions from that. Complex programs should grow from simple ones.
Design the interface so mistakes are hard to make. Where possible, avoid failure states such as syntax errors. If not possible, design prefered failure states, be helpful and friendly. Detect failures as quickly as possible and correct immediately. Allways provide a way to undo and go back.
Syntax is a layout problem
If there is one thing that would improve programming interfaces, it's better layouts and good typography. Why are we still stuck in a world of single-size, monospaced typefaces? Good notation requires a lot of subtleties. Give people the tools to express ideas visually.
Build a workspace
Usually, programming requires constant context switching: you jump between a text editor and your running program. You switch between the debugger, the documentation and searching online for a solution to a problem. Humans are bad at multitasking. Minimize the amount of context-switching that is needed by showing information in context, when and where it's needed. If context switching is unavoidable, provide navigation tools that allow for smooth transitions.