My travels indicate to me that "proficiency" grows from understanding the mental models that go into programming. Within a linguistic family (and most of the languages in heavy use are either dynamically-typed OO or statically-typed OO), the differences are marginal and mostly unimportant. If I had to go write Node ("like Play but without a working type system!") tomorrow--well, I'd quit, but before I did I'd be proficient in a week.
C++/C#/Java, less so Ruby, are really all kind of the same, OO languages, 3 statically typed and one not. But basically, they use similar ideas with different syntactical sugar.
I've recently moved to using Clojure/Lisp and I kid you not when not just the language but the tooling allows me to be an order of magnitude more effective when shipping production code.
I'm basically ruined, and now find it hard to get a job because I refuse to code in any other language. Because I want to be able to: spend time with the family, walk the dog, go surfing at 6am every morning, go to live jazz....._and_ still make sure I ship quality stuff on time. Clojure/Lips lets me do this :)
I loved the article because it was basically everything I've realised in the last decade; I am way more effective in one particular set of tools than another, and I don't want to have to learn python or Go or whatever, and all their associated libraries, community and quirks. I just want to use the shit I know and go do something else with my life :)
This is MHO and like I said milage will vary.
Oh about the job thing, I decided to start my own company so I could build it how I know I will be best able to do it.
I'm not unfamiliar with Clojure or Lisps in general; personally, I can't think as well in that mode and it doesn't map well to what I do (either in terms of work or personal projects), but I get it. They're nice, for a certain kind of thinking that I don't find myself needing that often.
I didn't mean to imply that there aren't tools where I'm more effective, because they're better tools, to be sure, (by my lights, Ruby is a better tool than Python and carving bits into a spinning disk with my teeth is a superior option to Go) but I find that after a certain point within an environment I've put together in my head a sufficient playbook where missing certain things here or there doesn't diminish my enjoyment of the process of building something. Libraries, quirks...meh. I went back to PHP a few weeks ago after not touching it for years and it all came back in fifteen minutes or so. Maybe I'm just wired for it? I dunno.
I know for myself, when I got a chance to code professionally in Erlang, I was hooked, and could not see myself going back to Java or a mainstream scripting language. Having to think and model problems concurrently, think about failure, etc, is so natural a fit for my brain that trying to fit a language that doesn't have those as first class constructs feels stifling, and having to eschew those concerns to write something that ignores the considerations Erlang prioritizes breaks my brain; I've tried it for timed coding events and it just did not work (i.e., realizing after the fact "Oh, yeah, I totally didn't need to spend time making sure that my supervisor tree made sense, that state was persisted properly, and resumable in the event of restart"). And yet it's not totally ideal, either; I care deeply about typing, and wanting to squeeze the most 'correctness' as I can from static analysis, and Dialyzer just isn't quite sufficient to fully scratch that itch.
Meanwhile I've seen some teammates who, while having the same diligence in thought, tend to be far more sequential, far more inclined toward single threaded models, reserving concurrency for the truly necessary cases, and more concerned with try/catch style error handling, than ensuring proper typing (Dialyzer) and otherwise letting it fail (at least until we know what we -really- need to handle).
Both I and my teammates have very similar backgrounds, coming from a predominantly Java background, some with a bit of .Net, Javascript, etc, with a smattering of mainstream scripting languages thrown in, and of course, we're all working on the same project. Yet our 'taking' to the language and its paradigms varies pretty drastically.
I think people, especially the HN crowd, miss that. PG's "Blub" paradox is viewed as the rule, and obviously everyone thinks they're at the top (or at least, as high up as is pragmatic for their domain), and while it's certainly true that you can't appreciate what you're missing if you don't at least understand it, people's brains work in very different ways. Languages certainly vary, and some are definitely better than others along a given axis, but I think it's unfair to take one's own experiences as objective truth. Even apart from domain differences, "This language made me 10x more effective"; yes, but is that due to the language, or due to your thought processes naturally fitting it? Will someone else who thinks differently find the methods of expressing problems in that language so naturally efficient that they'll see the same gains, or will it actually slow them down, even after learning it, because it isn't as good a fit for them?
I think PG's Blub Paradox only works to a point, as you say, and I think you nailed what regularly drives me nuts about technology: there are axes to this stuff that people mash into a continuum to feed their (rampant) insecurities--so they can look down on somebody. I think it's a sign of cultural and personal immaturity. I thought it was super-cool to issue sweeping statements about technologies at one point, and sometimes I still fall into it when I'm feeling salty, but I try not to. Which is different from sweeping statements about the craft of programming; Gary Bernhardt's twitter feed is chock-full of things that as a programmer you really should full-stop not do to your users. But technology--ehh. I goof on Go a lot, and it does drive me squirrelly when I have to debug somebody's Go project for work, but I just can't cape for any particular stack anymore. Even Java has plenty of uses. (For me, Java's useful in that I can see in my head roughly what the bytecode output of a given thing, and reason about its behaviors on the JVM better than I can Scala.)
I think the main difference to me was that Erlang was built from the ground up for fault tolerance. Everything about it is structured around that; you get process isolation and concurrency because of the need to not have one error/exception kill everything, you get distribution because you need hardware/VM issues to not kill everything. Akka's motivation isn't that; it can't do that. The JVM doesn't allow for process isolation, there's one shared heap, etc, so it really does matter what is running locally vs what is running on other machines, you have to be careful about mixing concurrency patterns and using vars, and it is possible for one process to die and take down others with it.
Akka is a little alien to me as well; things like 'become' seems a bit heavy handed (I believe it's due to the JVM not supporting tail call optimization, and Scala can't trampoline the calls if it doesn't know what you're trying to do). Similarly, the reactive nature of actors in Akka, where they don't do anything until they receive a message, while superficial, still bothers me a little bit.
My mental model of an actor in Erlang is simply a lightweight process that executes a function, that has a queue attached; at any point the process can check its queue, and if it needs to repeat itself or change its behavior, you call itself or a different function. It's a very simple mental model that all the OTP behaviors build on. Akka instead has (necessarily) various syntaxes; you're creating this ~thing~ first, setting up all the things it can do, and then it sits waiting for a message to start executing. It's trivial to transcribe one mental model to the other, but I find Erlang's is the one I think best in.
Now, that said, provided you don't need the soft realtime performance of Erlang, Scala/Akka is generally going to be more performant when it comes to number crunching; it's easier to just do it natively in Scala/Akka than have to do it externally in Erlang and open a port.
Scala/Akka benefits from existing JVM expertise which most devs have a bit of; the Erlang VM has its own deep knowledge you have to learn to run it in production (that said, the introspection you have into it is -killer-).
Scala/Akka is easier to transition people to, due to the OOness ("squint a bit and it can kinda be written like Java!"), but I think making a clean break of things with Erlang helped me; even the 'strange' syntax was helpful in that I didn't assume false familiarity due to syntax that seemed familiar (except for 'if'; everyone misuses that at least once). But if a dev finds that way of thinking alien to them, in the Erlang world they're just not going to be that productive; in Scala, you can mix paradigms and they'll likely see better productivity in areas of the code that are still very OO and imperative. I tend to feel there be dragons in OO, imperative code, but the reality is a lot of shops don't have the leisure to write everything in a functional manner, and to pick and choose who works on it based on their familiarity with that paradigm.
There are a few other odds and ends; Scala allows operator overloading which I need so rarely that opening it up is a con in my book, there's a lot of implicit stuff (apply for instance) that while really cool, allows for a lot of hidden dragons to be buried in a large, shared codebase, I really wish Erlang was statically typed as I said before, etc, but those are the main.
There's a huge gap in productivity - at least for small, exploratory, green-field projects - between C++/C#/Java and Lisp. There's a much smaller gap between Python/Ruby and Lisp, enough that a couple prominent Lispers [1][2] think that they are perfectly acceptable Lisps.
I like Lisp. I was pretty obsessed with it in college, and have gone so far as to implement a couple of them [3][4]. But my experience is that I'm perfectly fine with Python. Sure, I miss macros and conditions and CLOS. But that's all made up for by the awesome libraries available in Python, the ease with which I can express my algorithms, and the syntactic prettiness. I'm using it for my startup; I was just thinking this morning (while poking at a unit test in the REPL) that it's just as good or better than my Lisp experience ever was.
[1] http://norvig.com/python-lisp.html
[2] http://www.randomhacks.net/2005/12/03/why-ruby-is-an-accepta...
[3] http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_H...
I like Lisp and specifically Clojure, for a number of reasons, with a lot of those reasons being because it's the _same_ .....everywhere. I read Clojure code like I read English, I can glance at a piece of Clojure and not wonder why there is an implicit argument that needs to passed and where the compiler might be finding it; the rules for Scala static implicit resolution go in and out even after reading them a few times for me.
Clojure has a lot of improvements on CLOS, I'm not sure how much Clojure experience you've had? There's enough differences that some of the arguments I noticed in the paper (which seem to be really just syntactical) on why ruby is an acceptable Lisp don't really apply to Clojure. For example, in Clojure you don't use lambda, you use "fn" to do the same thing. One of the things I really like about Clojure is that I get to run it on the JVM, which still beats hands down the Ruby VM, AFAIK, I did check a little while ago.
I'm not that familiar with the Python REPL, but Clojure's is pretty good and I love being able to jack into production when I have to and modify executing code to do tracing or debugging without having to restart it :) I know, it should never get to that point, but testing only covers so much.
Ok, I think I'll leave it at that.
Another poster on this thread made a comment around, people think in different ways, some people love thinking C++ and classes for everything....I'm not one of those people, I want to just say exactly what I want to say and nothing else; if I want a class I'll make one, else get it out of my way. I think LISP so when I type it's an almost 1-1 correspondence.
Cheers!
p.s. nice work on the Javascript port of arc, I didn't know that had been done.
[1] http://www.infoworld.com/article/2609013/java/scala-founder-...
2. It's not like you ever let really go of the languages you already learned if you keep using it.
3. It's pretty obvious when a language has run its course. It shows in the job market. Why not transition then instead of staying on the Titanic?
For a reasonable definition of the word productive, I've never found it terribly difficult to pick up and be productive in a new language. Sure, a year later I'll look back and say "man, I was so silly back then" but that's not the same as being useless. We routinely hire people at work who don't have experience in our primary language and it's never been an issue.
One of the things that irritates me the most about our industry is the fetishization of the difficulty of switching languages. In my younger days people would say that the syntax was too difficult to pick up. Now that people realize that's hogwash they've moved on to saying that the frameworks are too difficult to pick up.