Is there such a thing as being ”too user-friendly”? I used to think there was no such thing, but delving deeper and deeper into Ruby, arguably the most user-friendly software programming language, I am not so sure.
Before I continue, I should state that I do not feel that being too user-friendly is a bad thing. I’d compare it to something being ”too sweet”, or ”too much fun”. You get the idea.
With Ruby, its an incredible experience. What starts out as an almost playful experience evolves into a paradigm with real gusto - before long, programming with Ruby has a tendency to make programmers feel empowered.
Ruby lets software engineers without formal training get their mitts on the innards of the language very quickly, and as they say - ”there be dragons”.
In my experience, Ruby has introduced me to some truly wonderful aspects of programming, including domain specific languages, or DSLs. These are limited syntax, focused “programming languages”, and the Ruby open source community is rife with them: Sinatra, Rake, Cucumber… there are plenty of great new ways to jot down logic with ease. Personally, I love it. Syntax makes a big difference in my humble opinion, its like the user-interface to the language.
In learning about DSLs, I’ve learned about metaprogramming , the act of writing a program that generates code and executes at runtime. This is another characteristic that is helps to define the Ruby Zeitgeist in the second decade of this millennium. And this is the area where I’ve started to wonder if a system can be too user-friendly.
I do not think its possible, but I find traces of those who seem to find Ruby to be dangerous in the way it exposes the components that define itself and allows itself to be redefined. Methods such as define_method, method_missing, instance_eval, and class_eval all seem to conjure up some sort of wary perspective in seasoned developers. True, haphazard use of these tools can certainly lead to unexpected behavior, or worse, data corruption or loss, but they are certainly not alone in that regard. Even the most stable software has bugs!
Also true, use of these tools can make troubleshooting and bug tracking more difficult. This is certainly a fair critique of their use - trying to figure out where an eval call went wrong can be a serious challenge.
However, I do feel that seemingly unwarranted use of these tools, just because they are easy to use, does have justification. One, they teach the developer about programming languages by offering a unique perspective on how programming languages function. Two, they make programming an exciting and empowering experience.
One of the inspirations for this babble was this post by Ola Bini. A commenter says it well:
The novice programmer is not to be feared. It’s the intermediate programmer, who knows the advanced tools but not when they should be applied.