Navigate / search

Some Functional Programmers Are Arrogant

On Sunday, I was preparing to fly home after Progressive .Net Tutorials in London. The conference had seen a big chunk of F# content. I’d spent a couple of days chatting with amazing people. Recharging the enthusiasm battery pack.

Apart from some heavy breathing on the mic for the first few minutes of my talk, and my inexplicably saying immutable when I meant mutable (multiple times), I was ok with how my talk went, feedback had been good.

The F# sessions were well attended, spirits were high, and to top it all, it emerged that Don Syme was to be awarded the prestigious Silver Medal by the Royal Academy of Engineering, for his work on C# Generics and the creation of F#.

It was a great week.

Then, a tweet.

Not this again. Functional Programmers are arrogant. Functional programmers drive newcomers away from functional programming.

It reminded me of Bill Hicks’ story about turning on CNN and seeing WAR, FAMINE, DEATH then going outside and hearing birds chirping. Where is all this stuff happening? Where are these arrogant functional programmers attacking people eager to learn, driving them away.

It reminded me of Bill Hicks’ story about turning on CNN and seeing WAR, FAMINE, DEATH then going outside and hearing birds chirping.

I’ve been programming since 1984 and professionally since 1996. So, yes, I’m a noob compared to Bob Martin, but dammit I’ve been around a while and nothing I’ve experienced in programming comes close to Functional Programming for sheer fun and a supportive community.

We started the Functional Kats monthly meetup in Dublin and specifically kept it non language specific to make it as welcoming as possible, and to allow users of different languages to learn from each other. Sceptical of Functional Programming? Then come along and use C#, Java or Javascript, or whatever. All welcome here.

Here’s the thing about people who are enthusiastic about functional programming. Most of them are just so relieved to find someone showing a genuine interest that they will bend over backwards to help you. To build you up. To make YOU feel smart.

I know this because I was on the receiving end of this generosity from the moment I showed an interest. This is why it’s frankly baffling when this charge of arrogance is levelled. Why functional programming? Of all the areas of software development, why is the arrogance of functional programmers a thing?

If it’s just a comment on the internet, a random tweet with no specific details, like this one

Then I just ignore it. I really don’t have the time or energy to deal with all the people that I think are wrong on the internet.

But this wasn’t some random tweet. This was Robert C. Martin. This was someone with a following, a reputation. This was someone speaking with authority. Worse than that, this was someone with a foot at least partially inside the world of FP. He has given talks on Clojure and even (I hope jokingly) suggested that we should all switch to Clojure and call programming languages done.

Worse than that, this was someone who has been on the receiving end of exactly these kinds of remarks. Craftsmanship is elitist. TDD’ers are arrogant. And not even random unsubstantiated claims. When Ted Neward (rightly in my opinion) raised questions about the link between Craftsmanship and the treatment of Heather Arthur, Bob took to his blog to defend Craftsmanship and swat back Ted.

At least Ted cited a specific incident. At least he called out specific bad behaviour, and it was bad.

Here’s the thing about people who are enthusiastic about functional programming. Most of them are just so relieved to find someone showing a genuine interest that they will bend over backwards to help you.

Bob issued a general tweet saying that arrogance is a “significant barrier to entry”. And I couldn’t believe it. He was legitimising random nonspecific comments about arrogance, with a random nonspecific comment about arrogance. (Yay..Recursion!)

Bob is better than this I thought. Bob should be better than this. Bob has to know that this tweet can be called on any time someone wants to lazily accuse functional programmers of being especially arrogant, without giving an example. More arrogant than OO programmers, more arrogant than DBA’s or DevOps advocates. More arrogant than C++ programmers or Agile Coaches.

Bob didn’t say some programmers are arrogant. He said some “functional” programmers are. He didn’t say some software craftsmen (or women) are arrogant. Actually he said they’re a great bunch helpful welcoming people. The Manifesto says they are.

Uncle Bob has jumped on the “Functional Programming/Arrogance” bandwagon, rather than use his considerable knowledge of computing history, and his considerable reputation within the industry to say, hold on, let’s all take a second and see if there really is a special arrogance problem in this particular field, or is this just received wisdom that people repeat without question.

Bob knows that arrogance and ego has been a feature of virtually every discussion in programming, from getting rid of GOTO to Static vs Dynamic typing. From how or whether to TDD, to how or whether to automate deployments. From Waterfall to Agile. From Pragmatism to Craftsmanship to Just Ship It. Hell the Javascript community almost imploded into an argument about semi-colons.

So, THAT is why I tweeted a reply

And that is why Bob asked me to elaborate, and that is why this post exists.

Is there arrogance in Functional Programming? Sure there is. Why? Because it’s programming.

Fred Brooks nailed it in the year I was born.

We work “only slightly removed from pure thought-stuff”

We build “castles in the air, from air, creating by the exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures….”

Of course all of us are arrogant some of the time, and some are arrogant all of the time. Of course. How could it be otherwise?

Google ‘Functional Programming Arrogant’. You’ll see some examples. Nothing really bad I have to say. I’d even posit that a lot of people dismissing FP as a fad or a bandwagon, or a bad idea without ever looking into it are showing as much or more arrogance.

Google ‘My Little Pony Arrogant’ there are far more results.

I’ll write another (much shorter) post about why I think this arrogance issue really exists, and what we can do about it, but tweets like that one from Uncle Bob are not part of the solution. They are part of the problem.

That’s for another day.



I googled “My Little Pony Arrogant” as you mentioned, and apart from one result that criticizes the fandom, the rest of the first page results are regarding in-show characters.

Which is ironic considering that you just wrote an entire article railing against this sort of mischaracterization.


Who said I was talking about the fandom? 😉


Nice cop out

Alex Darlington

I can understand linking functional programming and arrogance.
As a total hobbyist I have tried to learn haskell a couple of times and found it interesting but not really succeeded.

My normal approach to playing with a language is to play a bit with a few tutorials then attempt to use it for some real thing (possibly a bit too ambitious) that I want to do. In all imperative languages this seems to work OK, I can google the trickier things and with a bit of copying and pasting and hacking, get it to work. This process gradually helps me to learn.

With haskell, the basic tutorials are no problem, but the jump to making a real program with state, io, persistance leads to being told you need to understand monad transformer stacks and lens libraries. It is not just a bit more complicated (and I’ll try to understand some bits later), rather it feels like a quantum leap. When you ask for advice in some forum or other, it often seems you get so many conflicting and confusing replies, suggesting you should be using applicative monoids or leiningen lenses. Then, sooner or later someone will throw in some reference to homomorphic categories.

Finally you ask for opinions on how to quickly learn some of these things and fairly often the answer is that you can’t expect to learn them quickly. You need to patiently spend time gradually becoming familiar with the different abstractions.

So maybe no one functional programmer has been outwardly specifically arrogant to you, however the overall impression is that you are trying to learn something a bit too difficult for you and all the functional programmers know it already and don’t have the time to explain it to you from the basics.

So this is completely subjective and just my thoughts but I can understand the feeling of arrogance some people get from functional programming.

And I still want to learn haskell!


Hi Alex, thanks for that reply. I’m gathering together a few stories like this and I’ll try to write a post about this in the coming week. So I won’t reply directly here now, if that’s ok. But, I do understand the point you are making.

I will say that internet forums generally are increasingly a bad place to go for help in any area of knowledge. An approach that has worked for me is to forge a connection with one or two people. Perhaps someone you’ve seen speak, or found a video of. They will often connect you with others. Make a personal connection with real people and a lot of internet problems go away.

Richard Eng

As a retired, 20-year IT professional, I took a crack at learning FP (through Scheme) and I didn’t get very far. Perhaps it’s because after two decades using principally C, but also Fortran, Tandem TAL, C++, C#, Objective-C, Java, and Python, my mind was too set on imperative/procedural. But I also think FP is basically an unnatural way for humans to think and visualize the world. After my Scheme experience, I took a look at Haskell and was scared off. It just seems too much work is needed to climb the FP learning curve.

Despite what FP programmers tell you, FP is not a silver bullet for software development. I’m sure it has its advantages, but also disadvantages. I think it would be harder to teach FP to children. For these and other reasons, I don’t expect FP to gain much traction in IT. This must tick off FP advocates.


I’ve tried my hand at Scheme/Clojure and other lisps, and not gotten very far.
But I’ve had very little trouble with ML style languages, F#, Scala etc.

They are very different. The Lisps really are a level further on again, where you are getting into meta-programming, treating the code itself as data, using macros to transform it etc.

I certainly don’t think FP is a silver bullet, but nothing is. OO wasn’t and still isn’t. The no silver bullet argument is sometimes used to dismiss something entirely, but that doesn’t make sense. There are after all still bullets. It doesn’t make sense to go on using a sword just because all the available guns only have lead bullets.

Your last paragraph doesn’t tick me off at all. The children question is interesting. I have 4 coming along, so I’ll see how it goes. In a strange way I think tools like Scratch and Hopscotch that graphically introduce kids to coding fit very nicely with the expression over statement approach to coding.

I think FP already has gained traction, that’s a done deal. Big Data, multi-core and distributed processing make it more attractive all the time.


Functional Programming uses non-intuitive systematics and in my personal experience is championed by the most talented / educated programmers. The person who has the loudest blow horn in my community got a masters from MIT.

They “get” it and are quite frankly proud. “I can do lambda calculus, what’s your problem?”. It is a badge of honor for them. At least it is for my friend.

If I present some clojure code my MIT friend wrote to any other programmer in my circle of friends, the reader is likely to be unable to even say what the code does let alone identify a problem, correction or enhancement.

My MIT friend is unconcerned, they feel they are more productive and are able to write fewer lines of code, the consequences on everyone else be damned. If some reader does not “get” it, that is their problem not the author’s.

It is this attitude that gives rise to the reputation of arrogance that I personally feel is justly deserved.

FP is like contributing to the kernel with a community of Linuses ready to tell you what an idiot you are.


Hi Sara, I’m sorry that’s been your experience and thanks for the feedback. I’m planning a post dealing with some of these kinds of scenarios so I won’t reply in much detail here if that’s ok.

Richard Eng

I hear this all the time. FP programmers claim to be more productive because they write fewer lines of code. However, there is some evidence to suggest that FP languages are not necessarily more productive than imperative languages. In this study (, Haskell loses out to Delphi, Objective-C, Visual Basic, and Smalltalk in terms of productivity. So perhaps it’s not ALL about expressiveness and writing fewer lines of code.

And apparently, Lisp is not very productive at all, being worse than C++ and Java!!!


Hi Richard, thanks for that link. Capers Jones also had a study many years ago suggesting that the ratio of bugs to lines of code is fairly consistent across languages, so the benefit in less LOC probably isn’t in less typing, or quicker development, but in less bugs and easier maintenance.

Also, with functional languages there’s the issue of catching issues at compile time that would come to light only at runtime in other languages. So, again that’s something that has to be considered.

Finally, there’s tooling. I believe F# is a better language than C#, but if you wanted an ASP.Net site, I’d use C# because I wouldn’t be comfortable, and I’m not convinced it would be easier (as of now) to use F#.

So studies like these are really helpful, but in order to compare like with like, they can only work by building lowest common denominator

programs that are possible in all of the languages, and some languages will lend themselves more to those kinds of apps than others.

E.g. F# wipes the floor with C# when it comes to building parsers.


Hmmm. I’ve never been able to bring myself to watch that video by Erik. I suspect he was being more serious than Bob claims. Let’s just say, whether Erik is right or wrong, this one hasn’t helped build any bridges.


I have experienced less arrogance in the FP communities than in many other communities.

Especially those of Standard ML and Haskell are simply lovely.

Nowhere have I met so helpful persons. No pride.

Dean Schulze

I think Bob Martin likes to promote himself with controversial comments, and this is a case of the kettle calling the pot black. Martin has been pretty arrogant himself.

Martin used to go around saying that TDD was the minimum standard for professionalism in software development. I called him out on one forum by asking him if he considered Linus Torvalds and Peter Norvig to be amateurs since they dont’ do TDD. He waffled, and I haven’t noticed him going around calling non-TDDers amateurs any longer.

I wouldn’t be surprised if Martin eventually goes after FPers for not practicing TDD.


I think he has said that there are well known programmers that don’t TDD, whom he respects, such as Jim Coplien. Bob believes that in time TDD will be an essential part of software development that is taken as given for professional developers.

There’s a chance he’s wrong, but as an opinion out a possible future it’s perfectly sound.

It’s also possible that some way of development software that we don’t even know about will render TDD as we now know it redundant. For example there was a time when I couldn’t conceive of a way of developing without extensive use of the debugger. When I use F#, I never use a debugger.

None of us, Bob included really know what tooling and language improvements might do to the profession of programming.


∃f(p)∈Arrogant Fucks where p == programmers

Garth Gilmour

I believe there are two kinds of arrogance here that need to be distinguished. The first is that ‘X is the old real way to do Y’ e.g. ‘TDD is the only real way to write code’. The second is where ‘only the elite will be able to understand X’ e.g. ‘only real coders will understand Lisp/Haskell/Erlang’.

The Agile community is guilty of the first kind of arrogance (and then some), but not so much the second. Its the second that is still alive in the FP community. For example I’m one of many who started the Coursera ‘Functional Programming Principles In Scala’ course and gave up because the time commitments were ridiculously understated. I know several senior developers / architects who were soured on FP as a result, yet it seems to be a matter of pride amongst some in the Scala community that the pass rate for the course is so low. Similarly there are still many books, tutorials and training courses that start the reader half way up the ladder and expect them to build the bridge from what they know themselves.

Its been a while since I’ve looked at F#, and I’m sure the situation is much better now, but I was one of the ones who jumped on it back at the beginning but couldn’t find any tutorials explaining why the average C# developer should care. I remember Ted Neward did a blog post (way back in the day) lamenting about the excess of math and abstraction in F# presentations to humble enterprise developers.

I’m a big FP advocate in my day job and very aware of the amazing stuff the Functional Kats groups are doing (in both Dublin and Belfast) so this is not to tar everyone with the same brush. But serious work needs to be done to convince the average developer that FP is the way to go and there remain many in the FP world who don’t seem to think its worth the effort…


I respect Uncle Bob. A lot. And I get a sense of what he was saying. But I don’t follow his path, or Martin Fowler or GoF… They are kind of bareucract to me, they overthink and formalize too much, creating layers upon layers on top of actual code-logic (maybe because they’re are trying to create language-agnostic stuff they end up doing that?). I don’t think that good code/software is achieved by following rule of thumbs or acronyms. And I don’t thinks it’s actually very educational.

Eric Lubisse

I think that this perception (functional programmers are arrogant) and the underlying issues are going to be with us for a while. So much in our profession/industry seems to be based on opinions. And as you’ve pointed out we are prone to making broad categorizations largely unsubstantiated. These days I’m more inclined to acknowledge my preference and not feel the need to justify anything. I find the functional programming appealing. Even more so because of the calibre of people doing it. Admittedly the community is vocal (at least Clojure, Scala, F#, Haskell). To me that is simply a reflection of the desire to share rather than to show off or impose it on others. Not everyone will adopt the functional style or languages. I don’t think they have to. Its a free world. Ultimately the divergent opinions perhaps point to a reasonably healthy ecosystem.



Nice post on arrogance of function programmers. Yes at the first moment it ticks off, when somebody talks about isomorphism, lamda calculus, functors, applicatives … In my view it isn’t the arrongance but the learning process an imperative programmers go through to morph themselves to a functional programmer takes a while. After learning functional programming they become part of it and sort off start talking in the terms they think that other folks will understand. So its how functional geeks convey back in a simpler sense for other people to understand is missing.

We would like to share our experience in building a RESTful API server built on the functional way using and scalaz.
Here is the code:

We started with learning “Functional programming in scala” – course conducted by coursera by Martin Odersky. We put the initial code to work. Nobody knew the terms like “monads, functors ..”. But we basically abstracted saying “Ok these are patterns that we can do to efficiently code the functional way”.

Watch lots of videos by Michael Pilquist (My guru :),

John kudumal from Atlassian:

Poked opensource heavily done by others like stackmob (now acquired by paypal)

and we iterated our API server which has a tight error handling, JSON gets schema validated and data access layer on top a NOSQL db.

So it becomes a joy after math, to make the code compile. We found that once you have a framework done, it was easier to bring in folks to dig code. But yeah bit of an intimidation for new programmers when they start, but we are happy on the outcome.

We are building a continious integration wrapper for travis-ci, circle-ci now using Haskell and will be released under shortly.
To do this picked Google programmers brain from their Haskell version of Ganeti : to build our code.

Here are our talks

We plan to talk about it and evangelize

And yes, I bought “Category theory by Stephen Awodey” but yet to read beyond 1 chapter. so you don’t need the full theory behing lamda calculus and such, but how do you put all the concepts to use in a good way to solve your need.


I’m a newbie to FP, so I’m not considering myself to be a functional programmer. My experience so far has been that yes, it IS harder to learn (coming from a mainly imperative/OO background), than learning just another imperative/OO language. So most people will have to put in a lot more effort (I certainly will) whether they like it or not. And that’ll take time. Is stating this the same as being arrogant? No, it’s just how things are in my opinion. And personally I’ve not seen any arrogance from those already ‘in the know’ about it. Enthusiasm, yes. Fanboyism, also. But overall, no arrogance.
Thanks for the post!

Dean Schulze

@Richard – What I heard from Bob Martin didn’t allow for any compromise when it comes to TDD. TDD was the minimum standard for professional behavior in software development, period. If you weren’t doing TDD that means you are an amateur.

Martin also likened TDD to the discovery and use of antiseptics in surgery. No one would do surgery today without antiseptics. The problem with that analogy is that there is overwhelming evidence that antiseptics actually work and a theoretical basis for why they work. Martin, on the other hand, doesn’t have any metrics showing that TDD works better than other approaches and there’s no good theoretical reason why it should work better.

I would welcome some candor from advocates like Martin about the lack of legitimate metrics when it comes to what they are promoting. And lots of great software has been written without TDD, agile, and whatever fad comes next.

Have you ever noticed how often TDD advocates speak in superlatives like “Never write even a single line of code without first writing a test for it”. Do you want to bet that TDD advocates “never” write code without first writing tests?

The use of superlatives and lack of candor are pretty arrogant. Kettle meet pot.


I don’t agree with Bob’s position on TDD, but I have been wondering how to put Software Development on a more “professional” footing since about 1998, and I haven’t come up with all that much better than him.

I’ve come around to the Supremes School of Software Development.

You can’t hurry professionalism
No, you just have to wait
You got to trust, give it time
No matter how long it takes

Dean Schulze

@joecm – Interesting that you call Martin, Fowler, bureaucrats. They do all want to tell us that they know how we can do our jobs better.

Martin, Fowler, Jeffries, etc. all sell agile consulting services. Maybe that is why they are so adamant that whatever they are pushing today is the best thing ever…

Larry O'Brien

I wrote a column on this subject a few years ago:

I strongly feel that there is a problem. The organization that I refer to in that column produced, quite honestly, less user value than *any* team I’ve consulted with in 20 years. Why did they not ship a single new user feature in the previous 7 years? Because they were intractably dedicated to the belief that the only problem they had was that all existing software systems “were built wrong.” So they dedicated literally *years* of developer effort in order to… write a new build system. I think they’re done with that now (3 years after I left) and are now writing a UI framework. Their users, meanwhile, are still staring at a Swing interface programmed in 2002 that doesn’t support keyboard shortcuts.

And this nonsense, predicated on absolute certainty in their approach, is sprinkled with utter derision for object-oriented programming, a paradigm that’s proven accessible, proven teachable, and had been the dominant paradigm in two decades that have seen the developer community increase in size by an order of magnitude and the size of reasonable software projects grow by many factors.

It’s one thing to be a fanboy. *I’m* a fanboy of functional programming. But it’s quite another to disparage, as many people do in the functional community, a mindset / paradigm that not only *works* but over which functional programming has very little *proven* advantages. If functional programming offers 10x development, where’s the software? Where are the systems? (There are some! Someone claims they rewrote a financial system in F# and had an order of magnitude decrease in code size.)

Switching gears, another aspect is that there is not a single “functional programming community.” The Haskell community is different than the Scala community is different than the F# community is different etc. The Haskell community has, as Garth Gilmour points out above, a certain amount of “You have to be this tall to get on the ride” gate-keeping. The F# community is, I think, exceptionally friendly and non-judgmental.

Hakan Bayindir

I agree, some programmers are arrogant and all arrogant programmers are repulsive, however when this arrogance is shown by functional programmers, this becomes more repulsive. Why?

When programmers are arrogant in general, they judge your language of choice, library of choice and so on… When functional programmers are arrogant, they judge your “ability to program” directly. They attack you. Generally their undertone of their words becomes “Ha! you’re stupid that you are playing with these toy languages for idiots!” and this is annoying.

I experienced this first hand in a mailing list of a university’s cs department. There was one guy, always praising Lisp, functional programming and its virtues. When someone naively says that it’s doable in imperative languages in a handsome way to improve the conversation, the response was always a praise of functional programming, esp. Lisp again and again. I was trying to understand the landscape of functional programming in these days and thought I didn’t want to bother with guys like him while trying to learn. His messages just made me leave the list (after sending a massive rebuttal which have shaken the whole list down, as said by some of my friends).

I’ve not distanced myself from functional programming. I still want to learn, but I don’t want to ask anybody else. I don’t want to feel stupid or deal with anyone like him. I can learn it.

Also, I don’t believe arrogance is OK, because it’s programming. Yes it’s priveledge, and craftsmanship is elitist. Yes it takes time, blood, sweat and tears to become a true programmer, a craftsman, but true craftsman shouldn’t have ego. We should be open, approachable and teaching. We should improve ourselves constantly, but we must improve our surroundings, programming community and the world. Our craft requires and demands this from us.

I’m no programming superstar on the internet, but I’m not a run-of-the-mill programmer either. Being an exceptional or talented programmer doesn’t give me the right to be arrogant. In the contrary it strips the right of being so and gives me great responsibilities that I should be aware of.


Thanks Hakan. All of these messages are welcome and helpful.

I’m trying not to reply in too much detail to comments, but can I suggest that a mailing list of a university cs department might not be a great place to find a mentor, and certainly not a good place to avoid arrogance. But I understand that when it’s there it’s the obvious place to look for help.

In much the same way I’d advice not looking to forums for your introduction to a topic.

I’d suggest forging some contacts with real (non anonymous) people. If you are having trouble finding someone let me know.

Have you a particular language/technology you’re interested in? Or are you open to anything?

Hakan Bayindir

Thanks Richard for the kind reply. I was not looking for a mentor at that time, just happened to be subscriber in the list because of a friend who was attending. Bad part is, the guy who was harassing the whole list resident instructor in the university.

To be honest, my history is much like you and my profession is my passion and hobby. As a result, I’m open to anything. I have some Haskell books I bought but never had time to break the cover. If you can suggest anything I can also look at that way, so I’m open to anything.

Also being able to talk with open minded people like you is very refreshing, thanks for the post and the reply again.



One person in authority or with a platform can influence quite a few people, it’s always a pity to hear of people driven away from something they are interested in by an encounter with one or two individuals.

The first thing I’d say, and you already know it, is this is your career, not his, so don’t let him have a greater impact on it than you do yourself. It may be that functional programming is not for you, but you owe it to yourself to find that out yourself.

If Haskell isn’t doing it for you there are other options. Haskell is a pure language, which has pros and cons. If you are from a Java or C# background you may find Scala or F# easier to find your way into, and having done so Haskell may suddenly make more sense.

I love F#, I prefer it to Scala, but again, that’s a familiarity thing. I learned it first and have done more with it. Scala does have some thing F# doesn’t, like a greater chance of getting a job, for instance. 😉 (I’m going to get in trouble for that one!)

For F# I’d advise

FSharp For Fun And Profit
Try FSharp
The F# Koans

And I also have a number of posts on this site about learning to think functionally.

If I can be of any further help don’t hesitate to get in touch, I’m on twitter.

Good Luck

Yan Cui

Hey Richard, nice post and good to see different stories and experiences emerge from the comments. I like to throw my two pence into the mix here.

On the TDD front, it’s not enough to just write test first, the tests also need to “drive” their development ( which is something that I haven’t heard many people talk about at all.

Ultimately we’re trying to improve quality of our software and reduce bugs, and tests is just one way to do it (as well as providing living, always up-to-date specification of our software of course!). The thinking in many FP communities is leaned towards using the type system to provide a sort of formal proof for the correct working of our software, this is perhaps the reason why so many work has gone into the research of type systems in Haskell, and Idris, for example, and why we keep hearing people from these communities talk about category theory, etc.
Both approaches are valid – I see them as synonymous to the prevention and treatment approaches in medicine, prevent it if you can, treat it if you can’t – but neither is perfect and get us all the way there.

Also, in some areas of software development, maybe TDD isn’t the right way to build software? I work in gaming, and most of the time we don’t know what we should build until we have prototyped something, see if it’s fun, iterate on it and then settle on a set of requirements. It needs to be prototype driven, and writing test first just slows us down when what we need is to reduce the time between an idea and seeing it in action and getting feedbacks (or, the time to figure out what we should build).

On the FP arrogance front, from my personal experience I have seen some form of arrogance in just about any community, it’s a problem with humanity in general. I have seen far more blantant, in-your-face arrogance displayed in supermarkets than I do at developer conferences.

FP is also a pretty large space, encompassing many different communities within – Haskell, LISP, Erlang, F#, Scala, etc. – and whilst my involvement has mostly been with the F# community my experience there has been really positive and one of the reasons why I love F#.

Sure I occasionally see the ‘pride’ sipping through in conversations/debates (myself included!) but why shouldn’t people be proud about what they do, so long they have an open mind and willing to accept they’re wrong from time to time. After all, even Stephen Hawking makes mistakes from time to time ( so why wouldn’t we?


Great. As if the OO vs Functional debate wasn’t contentious enough, now you’ve roped in Israel.



Kevin O'Shaughnessy

You forgot to mention that the best comment on that Twitter thread who said yes some FP programmers can be arrogant but the F# community is actually a very friendly and welcoming one.

F# is both OO and FP so its harder to be both arrogant and a F# programmer.


I don’t get what all this is about. Some people do not listen carefully, and let their thoughts run off in any direction, the wrong direction mostly. The same happens to some people when reading.

Now, let’s have a look a the very small fragment of the tweet, that when overlooked, can cause so much turmoil. Uncle Bob tweeted “some functional programmers”.

‘Some’ IMHO only refers to a (very) small subset of the functional programmers. Otherwise Uncle Bob might have tweeted “many functional programmers” or “most functional programmers”.

So, it seems there is a misunderstanding, caused by not reading the tweet carefully.

Jaime Calahorrano

I think it was mostly towards Microsoft Functional Programmers so F# programmers, Microsoft and Functional programming a poising mixture for arrogance.

Leave a comment


email* (not published)