30% is an understatement. Think of the productivity gain when you go from assembly to C. Now, consider the fact (I do mean <i>fact</i>) that the jump from assembly to C and the jump from C to LISP are comparable.<p>The choice of abstraction <i>do</i> matter. If you use weak ones, your productivity is taking a serious hit: your program will be bigger, more complex, and have more errors (squared).<p>C++ abstractions, for instance, are incredibly weak. Take the function abstraction, which isn't even complete: you have no way to write anonymous functions the way you write literal integers[1]. Higher level concepts, as you call them, aren't more complicated than the "simple" ones. Often, they are just less familiar and more consistent.<p>[1]: Anonymous functions should actually be called "literal functions":<p><pre><code>    (fun x -&#62; 7 x + 42) -- a literal function
    357                 -- a literal integer
    2 + 3               -- expression which yields a integer
    f . g               -- expression which yields a function
</code></pre>
Nothing "high order" about that. This is just acknowledging that functions are mathematical objects like any other.