How to improve software design by using UX mindset, techniques and practices, given that the user of software design is the developer.

1. Usable Software Design
A Keynote by Alex Bolboaca

2. Günaydın Istanbul!!!!

3. Me
●
Facilitated first code
retreat outside US
●
Polyglot programmer
●
Trainer, Coach
●
Turned product
developer
●
CTO @ Mozaic Labs

4. From a Team That Brought You
●
Code retreats in multiple languages -
http://coderetreat.org/history
●
Brutal Refactoring Game
●
Taking Baby Steps
●
Teddy Bear Pairing
●
I TAKE Unconference
●
And now usable software design
http://mozaicworks.com

5. Me - Product Developer

6. My Current Product – eventrix.co

7. My belief:
YOU Deserve Better!

11. Naomi Weast
Actress, not a programmer
https://plus.google.com/110657773112027365790/posts

13. It reminds me of something else

14. Jacques Carelman
Artist, creator of “The Catalogue of Impossible Objects” in the 60s
http://www.patakosmos.com/wp-content/uploads/2013/09/RDA00147250.jpg

15. Coffee pot for masochists
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/coffeepot-for-masochists.html

16. Absorbent Bottle
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/absorbent-bottle.html

17. Siamese Hammers
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/siamese-hammers.html

18. It reminds me of something I read in a book ...

19. Donald A. Norman
Author of “The Design of Everyday Things”
http://www.jnd.org/NNg-Photographs/Photo1.jpg
“It is the duty of
machines and those
who design them to
understand people. It
is not our duty to
understand the
arbitrary, meaningless
dictates of machines.”

20. User Centric Design Process by UXPA
Revolution started by Donald A. Norman's book
http://uxmastery.com/what-does-a-user-centred-design-process-look-like/

21. Any design has a user.
Who is the user of
software design?
Can't be the end user.
Then: the developer
=> Developer-centric
software design? DX?
How about “Usable
Software Design”?

22. So how to apply UX techniques to
software design?
●
Personas
●
User journey for developer
●
Quality attributes
●
Usability testing
●
Specific practices

23. Personas

24. Developer Persona For Your Team
●
Kernel Developer
●
Java Enterprise Developer
●
Rails Developer
●
C/C++ Embedded Developer
●
Android Developer
●
Front-end Javascript + html + CSS developer
●
Etc.
Each persona
has different
needs.
Usability
depends on the
user!

25. Example of Team Agreement
Usable Software Design means to us that:
1. It is written for developers to read
2. It is easy to find where to modify the code
3. Any modification has a minimal ripple-effect
4. It is easy AND fast to validate that we did the right thing
5. We don’t have to do similar modifications in several places
Usable Software Design – A Federating Concept
by Johan Martinsson

26. Next Step: Practices
“It is written for developers to read”
=> coding guidelines, clean code etc.
“It is easy to find where to modify the code”
=> navigability, consistency etc.
“Any modification has a minimal ripple effect”
=> follow Open Closed Principle, Single Responsibility Principle etc.

27. User Journeys

28. You Are The User: Changing Code
●
Figure out what you need to change
●
Navigate there
●
Read the code, tests, documentation, comments
●
Write/change code, write/change tests
●
Refactor
●
Build
●
Validate
●
Integrate

29. Figure Out What To Change
Static structure
{},
Understand
runtime behavior

30. Example: Namespaces

31. Example: Modules

32. Is Your Design Easy to Navigate?

33. Is Your Design Easy to Navigate?
●
What module / namespace to look in?
– See previous examples
●
How is that thing named?
– Should be Consistent, Memorable, Precise
●
How deep is the inheritance tree?

34. Example: Consistency

35. Example: Modules APIs

36. Example: Modules APIs

37. Quality Attributes for
Usability

38. What is Usable Software Design?
Usable Software Design is
any code structure that exhibits
design qualities similar to usability

39. 5 Design Qualities of Usability
1. Learnability
2. Efficiency
3. Memorability
4. Errors
5. Satisfaction
http://www.nngroup.com/articles/usability-101-introduction-to-usability/
How easy it is to accomplish basic tasks the first time
you're using the design?
How quickly can you perform a task once you've
learned the design?
When you go back to the design after a period of not
using it, how easy is to become efficient again?
How many errors do you make, how severe are they
and how can you recover from them?
How pleasant it is to use the design?

40. 1. Learnability
How easy is it for users to accomplish
basic tasks the first time they encounter
the design?

41. Hints: Design For Learnability
Code structure that shows what the application does
Consistency
Minimal Surprise
Use Clearly Defined Modules With Clear APIs
Readability / Clean Code
Navigability
Add Usage examples – tests / comments etc

42. Test Learnability
Measure how long it takes for developers outside
your team to understand the purpose of a class
with as little help as possible.

43. 2. Efficiency
Once users have learned the design, how
quickly can they perform tasks?

44. Hints: Design For Efficiency
Use code constructs the whole team understands
Consistency
Fast Validation

45. Test Efficiency
Retro question: “what slowed you down in the past
two weeks?”
Measure how long it takes for developers to finish
typical tasks (not simple, but typical)

46. 3. Memorability
When you go back to the design after a
period of not using it, how easy is to
become efficient again?

47. Memorability ≈ Efficiency + Learnability

48. 4. Errors
How many errors do you make?
How severe are these errors?
How easily can they recover from the
errors?

49. Hints: Design For Mistake Proofing
It's the system's fault
Write automated tests
Eliminate exceptions
Pass mandatory arguments to constructor
(more difficult when using Dependency Injection libraries)
Avoid Primitive Obsession
Principle of Minimum Surprise

50. Mistake-prone Design

51. Mistake-proof Design

52. Test Mistake-Proofing
How many bugs do we have?
What is the main cause of the bugs?
(remember, it's typically in the design)
How can we change the design to avoid
it?

53. 5. Satisfaction
How pleasant is it to use the design?

54. Hints: Design For Satisfaction
Strictly personal, but relevant

55. Test Satisfaction
What parts of the system are unpleasant to
use?
How can we change them to be more
pleasant?

56. Usability Testing

57. How To Do Usability Testing
●
Pick a few common tasks
●
Ask a developer who is not part of the team but
knows the technology to do them
●
Gather the feedback
●
Define next improvement actions

58. The Tasks

59. I forgot to mention
●
You are not allowed to start the application, only
navigate through code

60. Results
●
First two tasks were too vague
– Create new event, create new user => write a new
feature? Create a domain entity?
– The feature existed, I was hinting at just creating a
domain entity and saving it from the code (no UI)
– It showed an inconsistency in design
●
Task 3 “Explain how an event is created in the
application” took less than 5'

61. ●
Task 4 “Validation for event creation” took less than 5', but it was
incomplete
– Claudia missed the client-side validation because...
– It was using custom tags extracted in a plugin that...
– Required to run “grails refresh-dependencies” but...
– It wasn't compiling because …
– It was using a library that …
– Needed compilation and publish to local maven
●
Improvement:
– Write a script “installDev” that installs everything needed for a new dev

62. ●
Task 5 “error management for event creation”
– <5'
– Correct answer

63. ●
Task 6 “Reset password flow”
– Stopped after 15'
– Got around the middle of the flow
●
Conclusion
– Difficult to follow a more complex flow through an
application
– Need some way to provide this information fast (work
in progress)

64. Open Questions
●
What was your general impression of the design?
– “very nice, easy to understand”
●
What helped you understand?
– “the names & the structure”
●
What prevented you from understanding the
reset password flow?
– “difficult to follow”

65. Usability Tests - Conclusions
●
Usability tests are very useful for improving
productivity
●
Every time you take 1' more to understand the
code, you are not implementing a new feature
●
(If you finish a feature faster, you have more time
to read Quora :D)

66. Design Elements

67. Design Elements =
Constrained Classes
●
Constrained Classes = Higher Level design
entities
●
~ design patterns (not quite)

68. Design Elements – Example from
eventrix.co
●
Controller
●
Command Object
●
Application Service
●
Database Service (Command)
●
Database Query
●
View Model

69. Controller
Responsibilities
●
Delegate the
operations on the
request input
●
Render the correct
view / template /
error
Collaborators
●
Command Objects
●
Application Services
●
View Models
How To Test:
Page Tests

70. Command Object
Responsibilities
●
Validate the request
●
Delegate update /
delete operations
Collaborators
●
Database Services
●
Database Queries
How To Test:
Unit Tests

71. Application Service
Responsibilities
●
Complex logic
●
Delegate all database
operations
Collaborators
●
Database Services
●
Database Queries
How To Test:
Unit Tests

72. Database Service (Command)
Responsibilities
●
Update / delete
database data
Collaborators
●
GORM subsystem
How To Test:
Integration Tests
With Real Database

73. Database Query
Responsibilities
●
Query database data
Collaborators
●
GORM subsystem
How To Test:
Integration Tests
With Real Database

74. View Model
Responsibilities
●
Transform GORM
entities into maps
ready for rendering
●
! Limit the data
returned to the view
●
! Separate as much as
possible
Collaborators
●
Domain Model
classes
How To Test:
Unit Tests

75. Design Elements Are Not Everything
●
We discovered some more – e.g. multiple steps
flow
●
Utility classes

76. But they are ~90% of the code
●
Typical use cases:
– Request to create / update / delete
something: controller → command object →
database command → view model →
controller render
– Request to read something: controller →
application service / db query → view model
→ controller render

77. Conclusions

78. What To Tell Managers
Usable Software Design has the potential to bring four
economical benefits:
●
Faster integration of new developers in the team
(learnability)
●
Faster time to implement typical (not simple) tasks
(efficiency)
●
Making less mistakes (mistake-proofing)
●
Feeling more motivated (satisfaction)

79. Recap
●
The developer is the user of software design
●
Usable software design means code structure that exhibits the
qualities of usability: Learnability, Efficiency, Memorability, Error
Treatment and Satisfaction
●
Define the personas of your team
●
Create a team agreement
●
Start applying practices that help the agreement
●
Run usability tests
●
Identify design elements from your code to increase consistency
●
This is just the beginning

80. My belief:
YOU Deserve Better!

81. Tell me about your experiences
alex.bolboaca
@mozaicworks.com
@alexboly
mozaicworks.com/blog
alexbolboaca.ro
https://www.linkedin.com/in/
alexandrubolboaca/

82. Buy my book!
Special price for you:
https://leanpub.com/usablesoftwaredesign/c/thank-you-java-day-istanbul
Pay as little as for two Turkish Pizzas

83. Q&A
“The important thing is
not to stop questioning”