I think the reason most languages are either SVO or SOV has more to do with memory recall time. Putting the subject at the start of the sentence maximizes the time the brain has to retrieve information about the subject, and probably then speeds parsing of the remainder of the sentence by priming information about the verb and object.

Interesting. So, there's more processing needed for the context associated with the subject and object rather than the action?

Verbs (i.e, actions) can be very ambiguous, especially the common ones (to be, to do, etc.) and to parse a phrase you must first resolve this ambiguity using the context of that phrase. This context comes from many sources, including prior phrases and things like social and gestural cues, but mostly from the subject and object of that particular phrase.

I'm not sure how relatively important the subject is versus the object for resolving ambiguity, but I'm hypothesizing that by putting the subject as early as possible in a phrase, SOV and SVO languages take advantage of priming effects (see http://en.wikipedia.org/w/index.php?oldid=257117356) to speed the parsing of a sentence.

(Edit: As a side note, I'm curious about free word order languages such as Russian -- with what frequency and under what situations do they use the various word orders?)

Priming effects play a much smaller role in sentence comprehension than straight short term memory storage and retrieval. Speed influence is possible but priming effects act on different timescales than that of on-line processes used for comprehension.

Regarding your other response above, which I mostly agree with, there is a common conception among Japanese speakers that in English, since the action is mentioned halfway in the sentence, one can often predict the meaning of the sentence and effectively stop listening; in Japanese (or any SOV), one has to pay attention to the end otherwise they will have understood nothing.

This is somewhat true, in that you basically have to "suspend processing" until the verb appears, whereupon can you "fire" the processes. (The part that is mistaken by the Japanese is that when an English speaker figures out the rest of the sentence is because the object is inferred. But the same level of understanding is available.)

Perhaps

  boy.ball.kick()

or just

  boy ball kick

This also reminds me of the way verbs can accumulate in German. (http://www.c2.com/cgi/wiki?ReadsLikeGerman) :)

I actually can't see how that works, at least out of the languages that I know, none of them fit the dot-syntax. The only ones that do (again, in the ones I know), are the lisp variants, but you need to flip the sexpr around. (I suspect the reason why lisp is "flipped" could be because programs are action centric whereas utterances are subject centric (this is a very risky statement to make, but interesting to think about.))

Anyhow, with this in mind, translating the above is absolutely trivial:

((action kick) (object boy) (object ball)) for prefix, or

((object boy) (object ball) (action kick)) for postfix

Boy.ball.kick() isn't an example from any particular language, but I was thinking something along the lines of "boy.ball" (the boy's ball) ".kick" (is kicked). That's different from boy.kick(ball), though.

In Forth, which is a postfix and stack-based language, "boy ball kick" would work by pushing boy and ball on the stack, and kick would pop two values, the kicker and kickee.

I just saw this comment and pedantically, I still think boy.ball is unworkable in this context (concerning SOV order and such).

The above expression illustrates a verb executed on a subject and object which are two distinct entities. This is your Forth example (which I agreed with earlier).

In the dot syntax though, you use it as an indicator of possessiveness, in which case the subject is reduced to "ball", modified by "boy". Furthermore "is kicked" is a passive form, which means it has an implied subject, which is the boy. Therefore the completed expression cannot be written as-is; you'd have to insert the subject (boy) into the expression and delineate it as a separate entity.

boy.kick(boy.ball) would convey this meaning. boy.ball.kicked() could also convey it, but in this case, the innards of kicked() must make reference to boy.