

Python for my Grandpa - parenthesis
http://www.voidspace.org.uk/python/weblog/arch_d7_2006_06_03.shtml#e356

======
silentbicycle
I think that trying to explain all this stuff (big sweeping gesture) to people
without technical backgrounds is beneficial exercise, for several reasons. Any
major programming or business work is going to involve quite a bit of
communication, with people as well as computers. Being unable to comfortably
explain how your creation works to a potential client is a great way to get
rejected, and is probably at least as damaging as being unable to be on the
same page as a collaborator. Also, explaining something to someone else can
help you discover aspects you don't fully understand, and often they have
useful abstractions that may not have otherwise occurred to you.

His Python explanation is a bit mystifying (particularly the hand-waving about
static vs. dynamic typing at the end; if he was going to just skip them, he
probably could have avoided bringing them up), but to his credit, this can be
_really_ hard to do well.

For one example, I'd compare the difference between an interpreter and a
compiler to an interpreter standing between two diplomats and a translator
slowly rewriting poetry or legal documents. The former has more immediate
feedback to work with (raised eyebrows, for starters), but has to do
everything on the spot, while the latter has a lot more time to rewrite things
concisely and elegantly. In this sense, an interpreting person who is quite
fluent in both languages and excellent at reading body language might be
comparable to a skillfully optimizing JIT-compiler.

I think mail-order packaging could be a useful metaphor for part of the
efficiency difference in static vs. dynamic languages: a static language
determines how much space something will need in a shipping container, while a
dynamic language saves time by putting most things in roughly the same size
boxes and loading them up with plastic shipping air bubbles. Granted, this is
only part of a complicated issue, but it's still a _useful abstraction_ ,
without getting into a bunch of details about boxed and unboxed types, type
systems, pointers, and other implementation details.

