Rod Johnson Is Right: The Scala Community Need to Grow Up

The one thing that has always bothered me about functional programming languages is that they seem to attract very intelligent and extremely arrogant people.

You might argue that these people are the loud minority of the functional programming community, and you might be right. But guess what?

It does not matter.

If you want to attract new people behind any cause, it is not a good idea to give an arrogant first impression. No one wants to join to a community whose members think that if you don’t get their point of view, you are not smart enough.

I repeat:

No one wants to join to a community whose members think that if you don’t get their point of view, you are not smart enough.

Arrogance does not build bridges. It destroys them.

For an "outsider" like me, it seems that these people value clever oneliners over solving real world problems.

I am a huge fan of writing readable code which solves the right problems. Although using oneliners is a nice way to demonstrate the features and the flexibility of functional programming languages, they have no place in the source code of production systems.

We are not writing code because we want to convince our colleagues that we are smarter than they are. We are writing code because we are solving a real world problem together with our colleagues.

We must remember that if our colleagues cannot understand our code, it is not their fault. It is our fault!

Rod Johnson gets this.

I enjoyed watching his ScalaDays 2013 keynote because he clearly understands that if the Scala community wants to grow, its members must

  1. Take a more pragmatic approach to software development. Most of the developers don’t care about oneliners. They care about solving real world problems.
  2. Stop alienating Java developers (and other new adopters). Intelligent and arrogant people end up playing with other intelligent and arrogant people. Why would a developer want to have any part in a community which despise her?

Scala Has Potential

That being said, I think that Scala has a great potential to be the next big enterprise programming language.

I had lost my interest to Scala mainly because I felt that the Scala community is full of immature and arrogant purists. Then I decided to participate to Coursera’s Scala course and I saw a totally different part of the Scala community. I saw people who were extremely helpful and newbie friendly. I realized that my first impression was not correct.

These are the people who can make Scala succesful. I am happy to see that Rod Johnson is one of them.

18 comments… add one
  • Ricky Clarkson Jul 4, 2013 @ 3:36

    Can you point to evidence of immature arrogance in the Scala community from the past year or so?

    • Petri Jul 4, 2013 @ 15:27

      I think that I already admitted in my blog post that the Coursera's Scala course made me realize that I was wrong about the Scala community.

      Also, I understand that the community cannot be held responsible for actions of a single person behaving badly. That seems logical, right?

      The problem is that humans are not driven by logic. We make irrational decisions which are driven by our emotions.

      Why this is important? Well, my first impression about the Scala community was not based on logic. It was based on my experiences with certain individuals who seem to think that OOP is shit and that FP is the silver bullet.

      Is it fair to blame the Scala community about this? Of course not! That is why I admitted in my blog post that my first impression was not the correct one.

      But I also think that the Scala community should remember that not all of its members are a) newbie friend and b) very good at taking criticism from an "outsider".

      The same thing of course applies to other communities as well. This is not something which is unique to the Scala community but I think that bad first impressions can hurt the Scala community more than traditional communities. I think that there are two reasons for this:

      1. It is still a rather small community when compared to communities formed around more traditional programming languages. This means that loud and unfriendly voices of the minority are heard loud and clear.
      2. Functional programming is a paradigm shift and developers might not be ready to change. Bad first impressions don't lower the resistance to change. They increase it.

      Luckily, the "official" Scala community has already understood this.

  • Olle Kullberg Jul 4, 2013 @ 13:45

    You are correct: it is important to be friendly towards n00bs. Hopefully you will see that the Scala crowd is very very nice community.

    If there are some loud, agressive, hyperintelligent individual bothering you, please try to ignore that person.

    • Petri Jul 4, 2013 @ 15:33

      "Hopefully you will see that the Scala crowd is very very nice community."

      I already addressed this issue on this comment. In other words, after I participated to the Coursera's Scala course, I realized that I was wrong about the Scala community.

      I wrote this blog post simply to point out that although the Scala community is cool, it does have the same problems than any other community.

      Also, I honestly feel that Rod's keynote had some great stuff in it. I agree that bashing the Scala libraries created by community members was an awful move but a lot of the stuff which he said made sense to me.

      • Olle Kullberg Jul 4, 2013 @ 17:42

        Sorry about my sloppy writing above.

        Yeah, I too liked the keynote, but I don't agree with the don't-re-invent-the-wheel argument. You should also know that some devs actively try to break the Spring dependency that exists in Java, so a Spring guy telling them to stop was not popular among them, or so I figure anyway.

        • Petri Jul 4, 2013 @ 19:45

          Don't worry about it. My comment was not published when you wrote yours. Besides, it wasn't rude or anything. I am actually quite fond of the word n00b because I when I feel like a n00b (or the dummiest developer in the room), I know that I have to keep on learning.

          As you probably guessed, I use Spring framework in my daily work. However, I am happy to see that it is not the only viable option out there. For example, I am happy to see that Java EE becomes better with every new release.

          And if we talk about Scala (or any other JVM language), I think that it is not wise to tell people to stop writing new frameworks for it just because there is a Java version available. Reinventing the wheel is not a bad thing if you can create something which is better than the original one (or at least better for your needs).

          These activities have also another benefit: these libraries can have effect to the language itself. I mean that these libraries can either be integrated to the language or act as an case study which drive the evolution of the language.

          And of course, writing libraries and frameworks by using a language which you love is probably fun and it can really help to build an active community around the language.

          And like you said, the big audience seems Rod as a Spring guy and Spring means "enterprise" to some people. Although his words resonated to me (mainly because of my background), I think that he should have been more careful when presenting his case to the Scala community.

    • itoctopus Jul 8, 2013 @ 21:00

      Actually the (un)friendliness towards noobs is something that is present in every language and in every platform.

      We see this unfriendliness when we see posts on the official Joomla website by some experts (well, those who think of themselves as experts) that try to make the person who originally asked the question feel stupid.

      What we need more in our profession (which is programming) is humility. Imagine if you're lost somewhere and you're asking for directions, you don't expect to be yelled at do you? Because this is what many programmers do to other programmers (with lesser experience) when they ask for questions.

      Unfortunately, the most important Q&A website for programmers (I don't want to mention its name here) is full of these people.

      • Petri Jul 9, 2013 @ 11:42

        I agree. Each community has people who poison the air with their negative and "witty" remarks. I have noticed that these people often want to elevate their own position in the community by making other people look (and feel) stupid.

        The funny thing is that no sane community will tolerate these people in the long run.

        "What we need more in our profession (which is programming) is humility."

        I could not have said it better myself. In my opinion, a great software developer understands that he is a newbie too. It does not really matter how much you know about X, there is always someone who knows more about X than you do.

        "Imagine if you’re lost somewhere and you’re asking for directions, you don’t expect to be yelled at do you? Because this is what many programmers do to other programmers (with lesser experience) when they ask for questions."

        I loved this example! Does this happen in real life too? I have noticed that people who act normally in real life, can be real assholes on the Internet. I guess it is easier to do so because the person is not sitting or standing next to you.

  • Jesper Nordenberg Jul 5, 2013 @ 14:07

    It's unfortunate that you've experienced "extremely arrogant" people in the FP community (but, as you write, not in the Scala community). My experience is 100% the opposite, I've learned more in the last few years since I started with FP than in the previous 15 years working with Java and C++. I'm now sure that FP is the only viable solution for tomorrows software problems, and that OOP is vastly overrated. It's true that the FP community involves more people with an academic background than for example the Java community does, but my experience is that they are very helpful and friendly (not so surprising as many teach classes at universities), and certainly not arrogant. People like Simon Peyton Jones and Martin Odersky do an amazing work educating people about FP and its benefits. But as all academics (and intelligent individuals) they are not easily persuaded by mere subjective and pragmatic arguments, you have present a solid theoretical reasoning to argue for your case (this is in sharp contrast to the Java community). This is a good thing IMHO as there are too many toy languages designed with no real knowledge about type theory which becomes a total mess of badly designed features.

    • Petri Jul 5, 2013 @ 17:15

      I think that I said that the functional programming languages seem to attract very intelligent and extremely arrogant people. That was only my first impression. After I participated to the Coursera's Scala course I realized that my first impression was not correct.

      I think that these (unfair) prejudices are born from the clash of two very different worlds:

      • The first one is the academic world which has heavy influence in the functional programming community. The inhabitants of this world rely on solid theoretical reasoning.
      • The second one is so called practical world where developers tend to value practicality over theory.

      In other words, the inhabitants of these worlds value different things and in a way, they don't even seem to speak the same language.

      I was (am) an inhabitant of the practical world and I found it a bit hard to get excited about FP because the language which was spoken by the inhabitants of the academic world seemed like mumbo jumbo to me. Then I heard statements like this (no pun intended towards you Jesper, I just use these as an example):

      • "I’m now sure that FP is the only viable solution for tomorrows software problems, and that OOP is vastly overrated."
      • "This is a good thing IMHO as there are too many toy languages designed with no real knowledge about type theory which becomes a total mess of badly designed features."

      When I asked why, the answer was probably theoretically sound, but it sounded like mumbo jumbo to me. Eventually the other side got tired of my stupid questions and the discussion ended (I don't blame him about this. It must have been an extremely frustrating discussion to him).

      I ended up thinking that this guy is an arrogant ass. He probably ended up thinking that I am a dumb OOP fanboy or worse.

      That was my situation before I participated to the Coursera's Scala course. Although I felt that the lectures were a bit too theoretical to me, I managed to understand them with the help of Coursera's discussion forums (I also bought Programming in Scala which was helpful as well).

      The main reason why this experience was so positive that I was not treated like an expert. These people did not expect that I understand functional programming. They used the language of the pragmatic world (and a lot of examples) to explain how things work.

      The lesson what should be learned from this is that if the Scala community want to attract inhabitants of the practical world, it must change the way Scala is advertised to these developers.

      Small and simple words work better than solid theoretical reasoning. Who knows, maybe these people get excited and study the theory as well.

      • Jesper Nordenberg Jul 6, 2013 @ 14:36

        I think I was in a similar situation as you are in when I started learning Scala a few years ago. My programming C++/Java skills were good, but I was very engineering/computer oriented (solving real software problems). There's nothing wrong with that, but after discovering Scala I started reading up on type theory and discovered the simple beauty of FP and how you can build software based on solid mathematical foundation. If you really want to broaden your mind I suggest you learn Haskell. It was definitely an eye-opener for me and has made me a much better programmer (even if I program in C++ or Java). I'm sure you're a very competent Java developer, but my suggestion to you is to go in with an open mind, without prestige, and be prepared to re-evaluate everything you know about programming. There are better ways to do things.

        The downside of learning FP is that you will find it very awkward, tedious and error prone to write software in languages like Java, C++ and to a less extent C#, but that's a small price to pay :)

        • Petri Jul 6, 2013 @ 22:06


          I agree with your analysis about my situation. I think that the learning process is the same for any programming language:

          1. You learn the syntax and write small programs with it.
          2. You get interested about the theory and try to absorb as much as possible.

          I think that the reason why developers are not interested of learning new concepts is that they are "happy" with the status quo and often afraid that these new concepts might make their current skills obsolete. This is a disaster if you are writing code for a living.

          The problem is that instead of learning those new skills, these developers spend a lot of their energy for resisting the change which threatens their livelihood. I know because I used to be one of them.

          Then I realized that if the change is meant to happen, it will happen regardless how I feel about it. In other words, I might just as well start investigating these concepts and see if they make any sense to me. Also, like you mentioned, learning new concepts will make you write better code with other languages as well.

          By the way, you are not the only one who has recommended Haskell to me. It seems that is a somewhat popular choice if you really really like functional programming.

  • Greg Jul 5, 2013 @ 17:28

    I'm not getting the gist of these posts. The Scala+Akka communities has always been warmly helpful to my noob questions over the last 2 years of my learning. There might be a bit of what might seem elitist in the community around scalaz, but recognize it for what it is. Tools like that are complex and "next-level"...certainly not intended for Scala beginners. The concepts aren't immediately obvious any more than OO was when it first came out. I never got the feeling anyone was talking down to me...I just didn't always understand the answer out-of-the-box. can be a fantastic Scala programmer without ever climbing that mountain (although it's well worth the effort!).

    Let me end by flipping the coin over. I have seen people in the Scala community go above and beyond. I've posted chunks of code that had me stumped and good-hearted people have consistently taken their time to read my code, and with uncanny regularity, find the problem with it. I think that's why, for a relatively small community, there is such a wealth of searchable problem/fix content on StackOverflow and other forums.

    Best wishes to you in your effort to get to whatever the "next-level" of Scala mastery is for you. The community is behind you.

    • Petri Jul 5, 2013 @ 19:01

      Thank you for your comment!

      I have addressed this issue (the Scala community) in my previous comments and I think that I wrote a blog post which has three main points:

      1. My first impression about the Scala community was incorrect.
      2. The real Scala community and people's mental image about it are two different things.
      3. Rod Johnson made some great points when he talked about the steps which are required if Scala wants to become a mainstream programming language.
  • joseph Nov 20, 2014 @ 6:57

    scala community must give a reason why Java developers should move their butt and learn this language

  • Dale Apr 17, 2015 @ 23:32

    You are not the only person that felt as if Scala communities were difficult to deal with in particular. Bruce Eckel, author and language design expert, mentions this same experience when trying to learn the language. It has been said, and makes sense to me, that a lot of the difficulty lies in the fact that the language draws in two groups with very different ideas on how to do things. So there is already a battle going on even before the n00b enters the scene. See:

    • Petri Apr 18, 2015 @ 11:42

      Hi Dale,

      Thank you for your comment. I watched the Bruce Eckel's presentation and it made me think of the reason why n00bs can seem so damn irritating.

      The obvious reason is that these people have their favorite programming language and it is not (yet) X (Scala in this case). They want to know why they should start using another programming language, and learn new libraries and frameworks. Often these people try to find an answer to that question by questioning a lot of things that seem clear to a person who uses X every day. And since the n00bs might not necessarily understand the answers, they might either think that X is not for them, or they continue questioning things until "the expert" explodes.

      Ironically, these n00bs would probably be very eager to switch as long as someone shows them

      • Why they should do it.
      • What libraries (or frameworks) they should use for X. In other words, often people are afraid to change because they don't know how they can handle persistence, security, and so on.

      It seems that building a community is a lot harder than you would think. One reason for this is that good technical skills won't help you to build community. You need to have good human skills as well.

Leave a Reply