The word "intuitive"... isn't.
First off, thanks to everyone who wrote
in with different interpretations of what the word “intuitive” really means. I agree that Jef Raskin did not have the final say.
Intuitive does not only mean familiar
. It can also mean consistent, stable, discoverable, and exhibiting affordances. And some other things. The reason it means different things is that “intuitive” is not a concrete or objective property of software. It is the result
of a good combination of objective properties. “Intuitive” is the result of good design, not the cause.
And this is why it is not a very helpful word. Like good design, it means different things to different people. So saying that such-and-such a programming language is “intuitive” is far less meaningful than saying it is consistent, or stable, or discoverable, or “familiar to C++ programmers.” Intuitive is a word people use to describe their subjective impression of whether something is well designed. Someone can always argue with the word “intuitive,” but we can all agree on objective characteristics like whether Java or PHP are consistent. Or we can compare the intellectual surface area of Haskell to Ruby.
So on to why a programming language cannot be better without being unintuitive
All programming languages are equally powerful. So what does it mean to be “better”? Better is a subjective word, a result, just like intuitive. The sentence is consistent, because it compares two subjective things to each other. And obviously it makes a lot of sense if you accept Raskin’s rather narrow explanation that intuitive equals familiar. (Although narrow, it fits my experience when talking about how non-professionals view end-user software: In a recent project, clients were still claiming that search boxes for each field in a table were more “intuitive” than a single full-text search. Naturally, these were older managers who had spent their formative years working with ASCII applications that worked on that principle.)
So for the narrow explanation that intuitive springs from familiarity, a language cannot be better without being unfamiliar. Well, how can it be “better” if they’re all Turing Equivalent? Only in a subjective way; only by making you
better. And in that sense, a language is only better if the process of using it makes you better as a programmer. Which comes from being moved out of your comfort zone
and into a place where you must learn, and where the things you learn are productive.
Not rote memorization of when to use .length, .length(), .size(), or .getLength(). But rather when you learn new ways of thinking about the problem to be solved. Not every unfamiliar language is better, but every better language is unfamiliar.
Now what about the other ways you can arrive at software that feels “intuitive”? What about a language that is unfamiliar but consistent, stable, and discoverable? Won’t it be better? Well, yes, of course. In fact, it will be a better better
than one that isn’t. You will learn more from functional programming in Haskell than functional programming in Ruby.
But what if a language was familiar but improved on what you already use by being more discoverable, more consistent, more stable, and so forth? How much better could it really be? In the sense of improving you as a programmer, how much personal value can we extract from a language that improves upon the familiar while still being familiar? Raskin suggests we will obtain at best minor improvements. Is Java really only a little better than C++, if at all? In the sense of making you a better programmer, what does Java teach you if you are already a competent C++ programmer?
(Of course, a straw man interlocutor can ask, “But what if I don’t already know C++? Isn’t Java a better language for me to learn first?” Ys, it may be a little better to learn. Perhaps. But in that case, the premise of the post is assured since neither
language is familiar to the beginner.)
Unfamiliarity is the driving force behind being better in the sense of a programming language. And “intuitive” isn’t a real property of programming languages, it’s the result of good design.