This is part of a series of notes from the Information Architecture Summit from 2012. All posts will be tagged ias12. This talk was presented by Paris Buttfield-Addison and Jon Manning (@thesecretlab on Twitter).

• Piles vs files: research from the 80s on understanding software by looking at the way people manage their pysical offices and workspaces: documents, scraps of paper on desks, filing cabinets, etc.
  • A piler heaps chunks of content all over their desk, create a very messy desk (most people are pilers)
  • A filer has an organized, rigid, controlled, possibly complex system for managing stuff
• Many users prefer working in clutter, measurably more productive and efficient. This is because piling lends itself to:
  • Discovery--finding links between two previously separate topics or projects
  • Reminders--it's at the top of the pile, front and center, so you'll remember it; things that are used a lot are close at hand, things that are new are on top
• Physical layout of stuff maps closely to their mental model; piles on the desk mirror how things are grouped in their mind
• People who are messier feel more in control, that they have a better grip on how their work is organized. They don't learn rules, the organization flows naturally from how their mind works.
• The real world is not a neat little box like your application may be: contrast between clean, simple applications surrounded by cave of clutter. The workspace is not their work, the room is their work.
• Filing creates a lot of cognitive overhead in addition to the actual work
  • extra stress if fail to adhere to system, not doing what you're supposed to
  • extra stress if something is misfiled--can't find it, what if other things are misfiled
• Take lessons from piling into computer, design interfaces for clutter (none of the following is about visual design: cluttered organizational system can still be visually clean). Applications should think in piles, too.
  • People put stuff on the desktop and understand that they'll come back to it back later; if they can't find it spatially they can use search
  • iWork suite on desktop & iPad: iPad has no unified tool to represent document, each one must have its own representation of files. In Pages, most recently used stuff goes in the top left.
  • Top sites in safari: behaviorally the same as bookmarks but there is no categorization, it's generated as you browse
  • Twitter favorites: most people use to save tweets with urls to read later, it's a pile with the most recent on top
  • All of these feel relaxed and the user knows where their stuff is. There is no overhead, it's simply put there and the user knows how and where to get it when they need it. Flexible, no restrictions.
• Making a clutter-friendly app does not mean you can be lazy about thinking about organization. It's actually more work than a rigid system because you have to
  • make app conform how people really organize their work
  • make it so the user can always find where they were and quickly get to it and go
  • let an emergent structure appear; user may never notice, and doesn't have to express preferences, it just emerges from how they work
• Responsive but not smug
  • Intelligent agent is designed to work with user in semi-human approach; never intelligent enough. E.g. Siri: has a very limited set of commands that it can actually respond to even though it converses like a human and uses human voice, fails expectations
  • Safari top sites just quietly organizes sites; done well, the user never even notices
  • Pages for iPad: uses animations to move most recent document to the top left, helps tell the user about thge layout of their work and build mental model
• Fault tolerant but not lazy
  • Encourage user to make mistakes because mistakes have no consequences, allows user to relax
    • Undo: we talk about it in terms of content, but rarely in terms of organizational structure. Gives people freedom to explore without the possibility of destroying things (e.g. undo menu in the finder can undo renames, deletes, etc.)
  • Encourage user to do what they want organization-wise
    • Stong rigid organization system makes people feel like they're not living up to what the design wants them to do (e.g. Jira and other bug reporting systems--however, see comments below on shared systems)
• Attractive no matter what kind of clutter the user puts into it. Allow for organizational complexity while still being visually clean. "If you're going to let your users make a mess it should damn well look good...because they're going to make a mess."
  • People put stuff in Pinterest and don't care about organization, but the layout makes the images look nice and clean even though they don't naturally go together
  • iPhoto works out which photos belong together (gps, time) and user can just create a group: filing system is done for you, obviates the overhead of filing system while still providing the organizational benefits
• Adapt your design constraints to fit what the user wants
  • Opposite of guiding users to fit your apps constraints
  • You need mental models
• Sharing piles of stuff is trickier. If piles are the user's mental model, it's hard to transfer that between people. You need something more rigid, e.g. Jira and other bug reporting systems (however, Trello is apparently more flexible?)
• Recency effect? people will look at the bottom of the pile when presented with a large pile of stuff so the stuff at the bottom doesn't get lost
  • also stuff is related, so people remember
• Scalability: e.g. in email, the bigger the inbox gets the more you rely on search
  • piling approach is really a variation of filing, piles can represent regions of time, can create archived folder monthly, yearly, etc. and remember the rough time period (can do in a way that doesn't impact your immediate needs)
• Present need vs archival need--how do I find the tweets that I like a month ago? piling facilitates now, but need structures and models for accessing later
  • often people don't need that, but iPhoto will generate archival system for you
  • the presenters have not not really been looking into the point at which they file their stuff away
• Duplication of data--ad hoc organization doesn't solve that, but filing after the fact could

Key take-home points for me:

I think the most interesting part of this presentation was not just that the applications I develop should allow people to organize things how they want, but that it might be possible to create a no-overhead filing system that symply emerges from the stuff being organized so there can be benefits of both piling and filing without any of the extra work. I love the example of iPhoto creating groups automatically using data embedded in the photos, and I'm going to think about how I do things like that in my future projects.