...which is exactly the same as "visiting each one and whispering in his ear"! With a for loop you still need to know how many "troops" you have and then go and do something with every one of them, one by one.
"foreach"-style loops with iterators in many languages eliminate the need for knowing how many element you exactly have, but you still have the code for explicit "take the next element" operation.
Vectorized operations are the next logical step, where the code for iteration ("visiting each one") is completely hidden. So instead of explicit for-loop, or equally explicit map function, you just apply the operation directly to the list and get a list as a result. This is nice, because it eliminates A LOT of syntactic and semantic noise from the code which mainly works with collections.
Such vectorization is available in many languages as a library - for example in Python via NumPy, where you can say "numpy.array([9,6,7]) + 4" and get "array([13, 10, 11])" as a result. In J and APL support for this is built in.
Of course, that's one way to look at it, and a valid one. Most of the time I do too, but I can accept some degree if implicit behaviour if it's consistent and (conceptually) simple enough.
> the amount of overloaded meaning of existing operators
But this is not true in regards to J. In J and other array-based languages the number of overloaded meanings for operators is actually less than in "normal" languages. That's because in J all the operators work on arrays and only on arrays. No operator ever deals with things other than arrays, and in basic J there's just one thing other than array anyway (a box).
In Python this:
2 + 2
and this:
[1, 2, 3] + [1, 2, 3]
are two different operators, but in J (ignore syntactic differences) this:
2 + 2
and this:
1 2 3 + 1 2 3 NB. resulting in 2 4 6
are both applications of the same operator.
There is a certain appeal to languages built on "turtles all the way down" principle - one of the benefits is that they tend to be compact, simple and consistent. On the other hand, when you're not dealing with turtles, they tend to be irritating at best and completely unusable at worst.
Anyway, I'm not trying to convince you to adopt J right now and start using it for writing web apps, I just want to say there are some interesting concepts in J which, while being unfamiliar, are not necessarily worse than the things we're used to. And they're not useless either: a week of learning J made my NumPy code much better, for example.
"foreach"-style loops with iterators in many languages eliminate the need for knowing how many element you exactly have, but you still have the code for explicit "take the next element" operation.
Vectorized operations are the next logical step, where the code for iteration ("visiting each one") is completely hidden. So instead of explicit for-loop, or equally explicit map function, you just apply the operation directly to the list and get a list as a result. This is nice, because it eliminates A LOT of syntactic and semantic noise from the code which mainly works with collections.
Such vectorization is available in many languages as a library - for example in Python via NumPy, where you can say "numpy.array([9,6,7]) + 4" and get "array([13, 10, 11])" as a result. In J and APL support for this is built in.