No, the reason Blub programmers have a hard time picking up more powerful languages is that they have invested time in their skillsets, so even if they were to program in Lisp syntax, they'd still write Blub-in-Lisp code, not using macros, closures, functional programming, etc. Because they never learned about them and don't see the point.
The same thing comes up all the time in Python communities; people who don't know Python very well write "un-Pythonic" code that doesn't take advantage of the language's best built-in functionality like list comprehensions and generator expressions.
# unpythonic way of squaring each element in a list
source_list = [1, 2, 3, 4, 5]
dest_list = 
for x in range(len(source_list)):
[x*x for x in [1, 2, 3, 4, 5]]
Sadly I think most people are not taught how to think, but rather how to perform repetitive tasks based on some formula (works great for writing Java).
Another problem I think is that most Blub programmers don't program because they love programming and therefore are not willing to put in the time and effort to learn a different way of thinking.
Personally I believe programming is an art and as such it requires talent as well as dedication. I'm disappointed that after all this years everyone still thinks programming is some form of science. Software engineering? WTF?
I've got to say that this is practically like learning to program all over again.
I'd almost go so far as to say that it's like learning to program. Period. Regardless of the years of experience in those other languages....
I did love programming, though... even though I was so Blubby. As long as I wasn't pushing the limits of the languages, I wouldn't think to look anywhere else. I didn't quite imagine that real Computer Science (like SICP) could benefit me-- given how atrocious so many programmers I'd met that had even Master's Degrees were.... Now I feel like I've wasted years and years of time.
(Why didn't anyone tell me? Ah... but would I have paid attention if they tried?)
# Pythonic way
# Correct way (...in any language, and if I see anything else in my co-workers code, you damn well better believe there will be a re-write):
List dest_list = squareEachElementInList(source_list);
Well, that had better be wrapped in a needless function, too:
# Correcterest way
assignSquaredListToVariable( dest_list, source_list);
A function hides the implementation.
to traverse a list
Because there are different ways to traverse a list. An arraylist is easier to traverse with respect to CPU cycles and memory usage (typically) than a linked list. What does python use internally? I don't know, and I'd just as soon decide that myself...
square each element
While there are only so many ways to square numbers, for more complicated things, you are doing to want to change implementations while keeping it all hidden. In java, you are occasionally going to want to splice in native code.
recombine them into a list
I may not want to recombine them in a list, but square them in place. A function makes that trivial, and further makes it trivial to decide when and how to do that.
--> The real reason is one of readability. More english, less brackets and commas please.
Re: different ways to traverse a list and square elements, whenever the idiomatic implementations in your language are good enough for you, you just want to go with them. Hiding those details behind names is premature abstraction IMO. If you know you'll need your own list and square implementation, you can abstract that from the start. If you find needs for change that you didn't anticipate, the overhead of refactoring (or overloading operators, if it suits the problem) there and then is probably less than having abstracted everything that you might possibly want to change.
Deciding to square the list in place is not trivial at all. If you do that, you'd better change the signature of the function so that it doesn't return anything [Edit: or using whatever convention you have to highlight mutators, like bang! names in Scheme]. Otherwise, it's too easy to use the old list assuming it has the original values, or to mutate either the old or new references assuming they belong to independent lists.
Re: readability, you have to balance the familiarity of the syntax for a newcomer, and more importantly, the ease with which you can get acquainted to it, with its expressive power and its consistency with the rest of the language. If English was precise, concise, unambiguous, and consistent enough a notation, we wouldn't have many other programming languages.
More specifically, I find list comprehensions (and generator expressions in general) very quick to get used to, I find that they read well once you have acquainted yourself with them, I find that they have a great ink to information ratio that justifies making that initial learning investment, and I find that they feel right at home in Python.
Ah, here's a major difference between us: I'd rather not decide that myself, unless it becomes a problem.
dest = mapsquare(src)
Consider the possibility that C-like syntax and mixedCaseVerboseNames may be an acquired taste.
If you do square a lot other things than lists, it's probably best to say
dest = map(square, src)
For one-shot usage where defining square seems overkill, and where it's available and idiomatic, I find the list comprehension most readable.
Well, this is okay. Of course, in java, you have to hack it unpleasantly,
List dest = map(UtilityMethods.class, "square", src)
...you have to manually extract the method "square" from UtilityMethods.class and process it over src. One advantage: You can use UtilityMethods as a namespace and swap in different methods thereby.
I just can't find any reference of this. This is pretty common thing, ideas from a long time ago tend to stay in the publics collective memory as still being current.
The one that springs to mind is the "breathing" you see pregnant-in-labour women doing in hollywood movies (yet this technique was thrown out decades ago as having no effect at all). Yet it lives on in circles of people who aren't experts and repeat it amongst themselves as if they are.
A quick search didn't yield anything like this for Sapir-Whorf though.
As a taste, Pinker tracks the evolution of the myth that the eskimos have more words for snow than English-speakers. He explains how this myth was manufactured by anthropologists who wanted to give credibility to Sapir-Whorf, and eventually took on the status of a "fact", appearing in textbooks and so on.
But our non-Eskimo language doesn't fundamentally limit our capacity to comprehend the nuances of snow. We just add modifiers (e.g., 'wet' and 'fluffy') to "snow", instead of using a different word. And, actually, it turns out the Eskimos use modifiers, too.
The Language Instinct is a great read. Pinker's got a real talent for popular science writing that's accessible but not dumbed down. Check out his first hit, How the Mind Works, if you're interested in general cognitive science.
"... As long as our hypothetical Blub programmer
is looking down the power continuum, he knows
he's looking down. Languages less powerful than
Blub are obviously less powerful, because they're
missing some feature he's used to. But when our
hypothetical Blub programmer looks in the other
direction, up the power continuum, he doesn't
realize he's looking up. What he sees are merely
weird languages. He probably considers them
about equivalent in power to Blub, but with all
this other hairy stuff thrown in as well. Blub is
good enough for him, because he thinks in Blub ..."