
Code Density - llambda
http://www.brandonbloom.name/blog/2013/06/24/code-density/
======
spullara
This is a pretty good article and cuts at the heart of the "readability" vs
"understandability" debates I see. If we decide reading code is an O(N)
problem, where N = number of lines, then his argument makes sense and you
might just argue about the constant factor (he states 5, I bet it is closer to
20) between understanding a Java code base and understanding a Clojure code
base. But the real issue might be that understanding a Clojure codebase as is
O(N log N) or possibly O(N^2) if there are lots of interactions and lots of
new syntactical constructs.

Has anyone ever measured a Reading Comprehension score for languages?

~~~
seanmcdirmid
There has been a lot of research in the past in trying to come up with metrics
for cognitive complexity; e.g.

[http://en.wikipedia.org/wiki/Cyclomatic_complexity](http://en.wikipedia.org/wiki/Cyclomatic_complexity)

Much of this work, however, predates the heavy use of indirection and
relatively opaque abstractions. In my opinion, functional programming suck on
the "understand every bit of the program" metric given the amount of
indirection in code (e.g. via higher-order functions, OO languages can suffer
also via virtual dispatch and Hollywood principle architectures). However,
they potentially excel at "understand the program in the context of these
understood abstractions" metric.

Unfortunately, humans are very diverse in their abilities to learn and
understand abstractions, especially ones that are based on math. So some
people get FP very well, while many others seem to do better with the more
naturalistic (i.e. based on natural language) abstractions such as objects.
There are good reasons why OOP is more popular than FP beyond the vacuous
"they simply don't get it" arguments.

~~~
gizmo686
>There are good reasons why OOP is more popular than FP beyond the vacuous
"they simply don't get it" arguments.

I think the main reason is simply historic. OOP is a lot easier to implement
(in terms of reasonable runtime efficiency) than FP. Because of this, it had a
huge head start to get itself into common usage. FP has only recently gotten
to the point where it is actually competative on performace.

In terms of 'getting it', computers and programing were originally the domain
of people who were much more procient in math than now. I suspect many of them
would have been more comftorable with FP, but implenting it was way beyond
their time.

~~~
seanmcdirmid
Actually, FP is easier to implement given their simple semantics, it can even
be implemented to go very fast for a very long time (e.g. Caml). But most OOP
languages are imperative, which definitely maps to the machine more easily
(note: OO is orthogonal to imperative even if they are often coupled).

Object-oriented programming became popular when the number of programmers
increased dramatically in the 80s/90s. Most of the high-end programmers do
prefer FP, especially as they have the math background to appreciate it. But
everyone else...objects have a usability advantage.

~~~
stormbrew
> Most of the high-end programmers do prefer FP

I'd really like to hear an argument for this that doesn't beg the question.

~~~
seanmcdirmid
It is anecdotal and probably a bit too strong!

Many of the strong programming languages people I have met have been amazing
programmers strongly in the "FP" category. If you look at a lot of the PL
people that do dev work in Google, they belong to this category as well.

I'm not in that world personally. I attended WGFP once and found people like
Simon Peyton Jones to be crazy smart and able to work with through complex
abstractions quickly to find very elegant solutions. But I just couldn't think
like that, I'm more OO.

