What is #devexp?
1. Apply UX techniques to developer-facing products.These techniques and ideas include:
- Lo-fi prototyping and sketching
- Usability testing by watching people try to use your products without interfering so that you can get a realistic understanding of how people will actually respond. Some companies set up usability labs or run hackathons in order to get this kind of data.
- A wider range of techniques from UX research practitioners
2. Focus on the '5 minute Out Of Box experience'The idea here is that if you provide a library, developers should be able to go from downloading to "Hello World" in 5 minutes. You should test this with a stopwatch or even a screencast to prove this is possible. Ideally they should then be able to take the code from this 5 minute experience and evolve it as their requirements grow in sophistication without having to start over. Making a library that supports the same user from unsure novice to sophisticated expert is hard but pays off in terms of increased adoption and fewer questions on the mailing list.
3. Use convention over configurationThis was most clearly stated by the Ruby On Rails community but is rooted in a simple insight. When someone first starts using your API or library they have the least knowledge so that's the worst time to ask them to make lots of complicated decisions with far-reaching implications. This is why you, the developer of the library or API, should make the initial decisions for them by establishing conventions that can be overridden with configuration options.
4. Try to "design away" common problems rather than documenting workaroundsFor instance if your users struggle with getting OAuth working then create abstractions that handle it for them rather than documenting the 6 most common problems or writing up the 'simple 12 step process' for getting it working.
This is inspired by Don Norman's work on perceived affordances which says that things should be designed in ways that immediately suggest how you should use them. If you walk up to a door it should be obvious without reading any signs, whether you should pull, push or slide the door to open it. If the door needs to be documented with a sign then it was badly designed.
This theory of affordances applies just as well to developer tools and APIs. They should be designed to have affordances that encourage correct usage rather than documented to make up for deficiencies in usability.
The phrase (developer experience) and the hashtag (#devexp) comes from Michael Mahemoff but it's not a new idea. Its roots are in ideas and practices such as:
- Microsoft's usage of developer personas
- David Heinemeier Hansson's usage of screencasts to announce the Ruby On Rails framework and to show off the smoothness of their Out-Of-Box-Experience.
- The Ruby community's widespread application of convention over configuration
- Nat Pryce's OSJam presentation based on the insight that "programmers are people too"
- Jeff Atwood's 2005 blog post stating that "developers are users too."
- Steven Clarke's research and blog on the experiences developers have with development tools and frameworks.
- Josh Bloch's work on the impact of good API design
- My session at O'Reilly's Open Web Foo conference about "making APIs usable"
- Pamela Fox's crowd-sourced survey on the elements of a positive developer experience
That's why we've set up http://developerexperience.org/
We hope to use it to point to examples of great developer experiences as well as aggregating relevant tweets using the #devexp hashtag.
Please join us. You can start by using the tag "devexp" whenever and whereever you write about developer experience. Over time this will help us build up a body of knowledge that will do for developers what UX has done for users.
Add comments on Buzz