Uniformity in code is bad - it tells you that there's a common concern or pattern which should be factored out. Uniformity in code style is essential, the same way it is for prose.

Is it? In prose you say "first he rushed to the exit door, then he leaped down the stairs, finally he ran to get the train" while in programming it is better to write

    socket.close(); window.close(); file.close()

Analogies are like shopping carts: if you push them too far they don't work well and you have to lubricate them.

and similes often have a wobbly wheel to begin with.

It's one way the may be distinguished from analogies.

Comparing declarative prose in past tense and instructions doesn't work. "Rush to the exit doors, then leap down the stairs, then finally run to get the train." Humans need first/then/finally or else we might execute instructions concurrently ("Boil water. Dice an onion.") Although, these words are unnecessary if a the beginning a human is told, "follow these instructions in order," as a compiler is told to read files. "Finally" is the signal to stop executing after the last statement, compilers use EOF, close tags etc to achieve the same thing. So, the analogy is quite precise if imperative sentences and code are compared and the whole prose text is compared to the code plus the compiler.

Better prose is:

"He rushed to the exit, leaped down the stairs, and ran for the train."

Better programming is to factor out the action:

    [socket, window, file]*.close()

Just curious, is that taken from an actual language? Because I've wanted a feature like that for ages.

It exists in Ruby:

    [socket, window, file].each{|item| item.close()}

http://codepad.org/GqNp94Iw

It sort-of exists in Lisp-inspired languages (anything from Arc to Lua to Io) with appropriate boilerplate, for example:

    function apply(tbl, func)
       for key, val in ipairs(tbl) do func(val) end
    end

    apply({socket, window, file}, function (item) item.close() end)

http://codepad.org/SNWO1Y6K

It also exists with slightly different boilerplate in Perl:

$_.close() for $socket, $window, $file;

It'll work in JavaScript, too:

   [socket,window,file].forEach(function(o){o['close']();});

And all of these ways are longer and less clear than the original. Better to write code like Hemingway than like Proust.

You can also:

  [socket, window, file].map(&:close)

That just sends the :close message to each object in the set and returns a set of the results of each object evaluating that message. Yay, Smalltalk.

When I wrote that I meant it to be pseudocode, but it does seem to be valid Groovy syntax:

    class A{
      def close(){println "closed"}
    }
    def a1= new A()
    def a2= new A()
    [a1, a2]*.close()

I believe it exists in Cω via "generalized member access" without recourse to map/foreach-type constructs.

Indeed. Programming is more like writing math than natural language.

You don't want to write one paragraph like a romance novel, another like a patent application then a third like an advert.

Some artists do. Writing is an art, and breaking rules in art is not the same as breaking rules in programming.

If not, you just say "consistency is good" which also applies to architecture, painting and so on.