Shortly after writing Last week’s post, I found myself discussing it with a developer I’d just met. We started talking about the notion of explicitly thinking about usability when designing programming languages. It was mentioned that familiarity goes a long way to making something understandable, independent of how clear the design is in the abstract.
He brought up the example of Rust’s enums, which aren’t the same thing that any other language calls enums. The traditional terms for this feature are things like variant, sum type, or maybe tagged union. Unfortunately, the only languages that have these are somewhat obscure (Haskell and OCaml are the obvious ones), so using standard terminology isn’t going to provide that familiarity. I guess at some point someone decided it was close enough to an enum to make sense, and given that rust was designed for use by low-level systems programmers, attaching it to something the users have already heard of, even if it’s a bit different, was the thing to do.
Just as the two of us were saying to ourselves, “yeah, that’s probably reasonable,” a low-level systems programmer sat down next to us, and asked us what we’d been talking about.
I proceeded to try and miserably fail to explain the concept of variant types in terms of concepts and terminology he was familiar with. Eventually I gave up, got a fresh napkin, and just started explaining it using Haskell syntax and terminology. He got it fairly quickly.
I finished Don’t Make Me Think the other day. The book spends a lot of time stressing the importance of actually doing usability tests, and this anecdote is I think illustrative as to why.
One data point is not exactly science, but it’s a heck of a lot more rigorous than what we usually do with this sort of question.