This article is the best-articulated explanation of why programming should be a core part of the college, and even K-12 curriculum I have ever seen. I just can't agree more.
An anecdote.
When my girlfriend was still in school she needed to collect a great deal of data for a project. It was available for sale from industry groups and such, but she didn't have tens of thousands of dollars for a membership. So she resigned herself to harvesting it manually.
When I noticed what she was doing I pointed out that I could make this process easier for her by writing a small computer program. A few lines of Javascript and Python later she had her data, and in a small fraction of the time it would have taken her otherwise.
I explained, in general terms, what was going on in the program and why it worked the way it did, and explained some of the changes I could make if she needed it to work differently. The programming involved here was not in any way difficult or clever. The interesting thing was that she had never even considered the fact that her problem could be solved using computer programming.
She commented to me a couple months later, after I'd helped her with a couple other small problems in the same vein, that she had started to see problems that could be solved easily with a little bit of code everywhere she went. I didn't coach this response out of her, she was honestly amazed at what could be accomplished and she continues to view the world differently because of this exposure.
Now, she certainly hasn't become a "computer programmer" since (and she likely never will). But gaining a basic understanding of what can be accomplished using programming tools has actually changed the way she views problems.
Edit: I noticed people are concerned that having too many people with just enough knowledge to screw things up might be a bad thing. In my girlfriend's case the opposite has been true. She hasn't all of a sudden decided she can solve every problem by writing some code (or convincing someone else to write code).
On the contrary, she actually has a better appreciation for how computer programs work and why writing a new one may not be a good idea in all cases. For example, she understands why a custom application requires maintenance, and that maintenance isn't just some trivial thing that you hire an intern to take care of. In fact, she has actually talked her boss out of having new applications created because she realized that the projects would likely end in failure.
She might not be able to write a single line, but when I was explaining it at a very high level going through the code, it felt like she was trying to see how the computer would think. She's still of the belief that a computer can think on its own and we're simply asking it to do something for us (like you would a horse on a farm), but she really did want to know how I could teach a computer to do something it didn't know how to do before.
See e.g. for Haskell, originally as http://www.haskell.org/pipermail/haskell-cafe/2010-February/... and now as http://www.haskell.org/wikiupload/6/65/HIW2011-Talk-Tibell.p...
However, your graph will be much more complicated if libraries are allowed to influence each other, rather than strictly considering language features.
This walks a thin line for sure and in Scala the line is almost microscopic. I'll keep it for now since my reasoning was the same as the Erlang->Scala influence. A core language library that is rarely viewed as other than a core feature.
However, I think the question was about projects built with Clojure, i.e. how to ensure that future developers in the company I work for will be able to continue where I left off? The global Clojure talent pool, while growing, is still on the small side (e.g. compared to even Ruby).
http://janestreet.com/minsky_weeks-jfp_18.pdf See part 4 "Personnel" for Jane Street's experience hiring OCaml devs.
That said, I don't think the matter is quite that straightforward where I come from; I would imagine Clojure dev head count in the whole of Finland is in the low double digits. If I were making business decisions involving future staffing, I would not feel confident I could replace the (hypothetical) only in-house Clojure dev in this job market.
pure (== return) :: (Applicative f) => a -> f a
<$> (== fmap) :: (Functor f) => (a -> b) -> (f a -> f b)
join :: (Monad m) => m (m a) -> m a
pure x = [x]
odd <$> [1,2,3] == [True, False, True]
join [[1,2], [3], [4,5]] = [1,2,3,4,5]
Dr. Gray wrote "Transaction Processing"[1] that has proven indispensable in my career and a generally great book. I didn't know the man, but he influenced me deeply from afar. RIP.[1]: http://www.amazon.com/Transaction-Processing-Concepts-Techni...