
Some Functional Programmers Are Arrogant - ingve
http://www.devjoy.com/2015/07/some-functional-programmers-are-arrogant/
======
lostcolony
FP is largely defined by what it avoids, not by what it adds. All the other
bits, monads, higher order functions, etc, are necessary to finding workable
solutions to real problems while avoiding things that cause the badness. To
people who use those things avoided, it comes off as arrogant.

It's like with vegetarians. "I don't eat meat; there are plenty of plant based
sources of protein and I don't want to have to have animals killed on my
behalf". Nothing about this is factually incorrect, none of it is arrogant,
yet, because it's purposely avoiding something the listener consumes, the
listener may take offense, and assume the vegetarian is taking a holier than
thou attitude toward them. They assume that because the vegetarian views
eating meat as something to be avoided, that the vegetarian must be judging
them for eating meat.

Similarly, because the FP programmer views mutable state as a dangerous
practice, the listener who uses mutable state views the FP's attitude as
judgemental, "You're not using best practices!"

But, like the vegetarian who encounters someone who wants to try giving up
meat, and is asking for recipes and ideas, FP programmers will, indeed, bend
over backwards for someone who is trying to enter the functional world.

~~~
pron
FP is not defined at all. Pure FP (PFP) has a clear definition, but I
challenge you to find a definition for FP that includes Clojure, Erlang, F#,
and OCaml but excludes Java, JS, Ruby, Python, C++. All of these languages are
imperative with varying amounts of reliance on higher-order functions and
emphasis on immutability (for example, my favorite so-called-FP language,
Clojure, allows global mutation all over the place, but provides some
transactional assurances).

Second, even if we consider PFP alone (which is, indeed, different from
imperative programming), I often find that some of its proponents are lacking
in understanding of the theoretical underpinnings of imperative programming.
For example, day before yesterday I gave a talk at CurreyOn/ECOOP about why
monads are harmful in imperative languages (i.e. any language that isn't PFP),
and PFP experts present weren't aware (although, TBH, neither was I, but I'm
not a PL researcher) of this proof[1] that imperative continuations are at
least as powerful and easy to express as monads (I later claimed and provided
evidence that they're more powerful).

There is actually much to debate about the relative merits of PFP and
imperative, but I certainly wouldn't say that PFP is "avoiding badness". It's
avoiding some badness while introducing other kinds of badness (monads have
some serious disadvantages), while imperative programmers can avoid the same
badness without resorting to PFP (e.g. as Clojure and Erlang do).

[1]:
[http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.43.8...](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.43.8213)

~~~
DanWaterworth
> I challenge you to find a definition for FP that includes Clojure, Erlang,
> F#, and OCaml but excludes Java, JS, Ruby, Python, C++

Challenge accepted: FP languages emphasise restriction of mutation.

~~~
tel
Javascript has Object.freeze and Object.seal built right in! How is that not
emphasis? (He asks with a touch of both sarcasm and seriousness.)

(I seriously believe that any attempt to define FP will end in tears. It's a
marketing term and has no real likelihood of producing legitimate technical
value.)

~~~
DanWaterworth
Well, some people write very functional javascript. I've thought of a better
definition that circumvents the issue of what constitutes emphasis.

Functional languages are languages used predominantly by functional
programmers.

Being functional probably has more to do with how a language is used than the
set of features it boasts.

~~~
AnimalMuppet
I don't quite agree. Languages push you in different directions. Haskell
pushes you toward FP; you can fight the language and "do" (pun intended)
imperative programming, but it's going to be painful.

Can you do FP in any language? Maybe not COBOL, but you could do it in C with
function pointers. But it's still easier to do it in Haskell than in C, and
it's still easier to do imperative programming in C than in Haskell.

So you have a point. But languages have different characteristics, too, and
those differences let us classify languages, if not as "FP" and "non-FP", at
least as "more FP" and "less FP".

~~~
DanWaterworth
I'm not saying that every language is the same. I'm saying it's very difficult
to define styles of programming, but if you have a particular style (in this
case functional), you will gravitate towards languages that facilitate that
style. At the boundary, where a language doesn't have a particular leaning,
the style that you will adhere to is going to be influenced much more by the
community around the language than its features.

------
eropple
There are lots of nice people in FP circles and nobody ever said there wasn't.
But I think the author is taking the use of the word "arrogant" much too
literally--its users generally don't mean _arrogant_ , they politely mean
_asshole_.

My sense, from spending a decent chunk of time in a couple different
communities, is that they don't do enough policing of their jerks and that
that makes itself most apparent to novices rather than established people.
Many programming communities don't handle jerks well, for a host of reasons
around social standing and conflict avoidance, but of the ones I regularly
participate, I don't think a guy like Scala's I-think-I-can-use-the-
adjective-"infamous" Tony Morris--though granted, he seems to wish he was
Haskell's Tony Morris--would be tolerated past weeks, to say nothing of years.

I really like functional programming. But I find that notions like "shared-
immutable programming" are more accepted by people who've been burned by the
more socially toxic sections of the universe. The rebrand helps remove the
association with the jerks, and that should speak to the impact of those
jerks.

~~~
mcguire
Could you list us some programming communities that _do_ handle jerks well?
'Cause I'm having a hard time thinking of any.

~~~
Tehnix
Generally it is unpleasant dealing with unpleasant people. Sometimes though,
if a question has been asked many times or if people end up talking past each
other, hostility can arise and the ones answering can start becoming a bit
snarky.

I would say #haskell is usually very friendly, but no community is perfect. I
noticed the above once and it was actually quite easy and simple to fix it. I
simply joined in on the ongoing question session and started implying that we
should perhaps answer a bit more nice to the newcomer.

------
kendallpark
There are all sorts of "special club" mentalities in programming. Linux users,
vim users, functional programmers, never-touch-the-mouse-power-users... the
list goes on. Someone asked me why I used Linux and I half-jokingly answered,
"Because then I can be pretentious about hating both Windows _and_ OSX!"

Tis human nature, I guess, always trying to find a way to distinguish yourself
from the masses. A bit of a Star Belly Sneetches phenomenon.

[https://en.wikipedia.org/wiki/The_Sneetches_and_Other_Storie...](https://en.wikipedia.org/wiki/The_Sneetches_and_Other_Stories)

~~~
jaawn
I don't agree that it's "human nature." This type of behavior is significantly
more pronounced among programmers, "geeks", and gamers. I don't hear
administrative assistants bickering over calendar software, or post-it note
dispensers. I don't hear many of the business majors being pretentious about
their choice in spreadsheet software.

Everyone else seems to be a bit more focused on the result of their work, not
how they get it done. They certainly don't seem to take pride in their choice
of tool. Imagine if a construction worker felt self-important because _he_
uses the Aero Hammer 7, while _they_ use the _clearly inferior_ Aqua X Mallet.
It's silly. I don't think this behavior is as widespread as many here think it
is. _(edit: widespread among the general population)_

~~~
joesmo
The professions you should be comparing programming to in this case are not
admin assistants or spreadsheet users. Of course they won't care because it
makes no difference to them. How about computer graphic artists. Do you think
they care if they use 3ds Max or Rhino or whatever exists these days? How
about musicians? Do you think they care if they use FL Studio or Reason or
Cubase or Logic?

I could go on and on. The answer is a resounding YES to both of those
questions by the way. They care just as much as programmers do about their
software. It's not limited to software either. Writers who write by hand care
about their pen. __A lot. __People who put a lot of energy into their craft
care. Is that human nature? Absolutely. Is it human nature to then compare and
try to set oneself apart from the rest? Of course.

~~~
jaawn
It is true that I over-simplified and used careers that aren't very similar,
but that was kind of the point.

> _Of course they won 't care because it makes no difference to them._

Exactly. My point is that it _also_ shouldn't matter to programmers, in the
same fashion. Why does it matter if you use Emacs or Vim or Notepad? Why does
it matter if you use Ubuntu or Windows or OSX? If you can produce high-quality
work that is maintainable in roughly the same amount of time as someone else,
the tool you use doesn't matter.

People should have preferences and they should be able to use the tools that
are comfortable for them. However, any self-important feelings based on these
preferences are silly and don't really make sense. That was my intended point
originally.

~~~
gknoy

      > Why does it matter if you use Emacs or Vim or Notepad? 
      > Why does it matter if you use Ubuntu or Windows or OSX? 
      > If you can produce high-quality work ... the tool you use doesn't matter.
    

In all of these things, there is a shallow similarity, and a deeper difference
that is only visible to a user with expertise. Tools have Quality, and experts
care about it.

 _Professionals_ care deeply about their tools. Writers care about pen
qualities, musicians care about software and instruments, hunters care about
their weapon. Programmers care deeply about our editors, languages, source
control, and computer platform. Photographers care about their equipment.

Comparing Vim/Emacs with Notepad is like comparing whether to use a computer
versus writing by hand -- nearly no professional writer will choose to use a
pen and paper when they have the power of a word processor at hand, and
similarly nearly no programmer will choose Notepad over a professional code
editing tool.

You'll quickly find that many people who care about writing by hand care
deeply about not just pens, but the ink they use within them -- the depth of
nerdiness in the fountain pen forums is amazing. Consider looking at "fountain
pen reviews", for example.

People usually don't care about post-it brands or pen brands (or band-aids or
toothpaste) because, in most cases, they are __functionally equivalent__, so
you can decide on price or convenience. If one is not a discerning user, in
theory one might buy a set of kitchen knives, a coffee maker, a car, a suit,
or a computer based solely on price. Most of us have been burned enough by
low-quality tools to care enough to discern Good from Bad.

As programmers, we have the expertise to compare Python vs Ruby, or Emacs vs
Vim, or Linux/OSX/Windows. We might not have the same depth of caring in other
subjects (cars, cooking knives, pens, phones), and therefore do not engage in
the same degree of holy-war that we tend towards when evangelizing our
favorite tools.

~~~
jaawn
Debating the merits or pros/cons of any given tool is different from binding
any self-evaluations to your choices, or evaluating others based on theirs.
Writing someone off as "lesser" because they prefer Windows over Linux is
unreasonable. There are plenty of valid reasons to prefer Windows based what
you use it for. Disagreeing with those reasons does not mean the same thing as
thinking the person is "lesser" for it.

------
zxcvcxz
So the title is a little misleading, the author _does not_ believe arrogance
is a real problem in the community and claims to have to look hard to find
arrogance.

I'm not a big fan of the social justice community, but they are right about
arrogant programmers. They aren't racist or misogynist, they're equal
opportunity assholes.

In my experience most people who are oblivious to the arrogance of the
programming community are themselves the arrogant ones. There are a lot of
friendly people, but if you're a real noob and try to contribute shitty code
to a big open source project with real programmers, you're gonna get your ass
handed to you.

Even the groups of programmers who claim to support "safe space" environments
are chock-full of arrogance, they just don't use cuss words and belittle you
in a more passive way. I assume it's pretty much the same in every profession
when noobs make mistakes.

~~~
eterm
It's not just if you try to contribute bad code, just asking the wrong kind of
question can get a lot of crap back at you.

Of course, if you're genuinely a beginner you don't know you're asking the
wrong kind of question.

Yes, it's frustrating to help someone who is strugging to run/consume Foo only
to eventually find out what they actually wanted to do was Bar and that
consuming Baz would have been a much simpler solution.

But if you don't have the patience to help, don't try to! Too much programmers
think they can fix the world and go around trying to correct beginners[1] when
they should just get out of the way.

[1] Many high rep stackoverflow users suffer from this, they've seen the same
shit too many times and rather get out of the way and let others help the
beginners they'll shut down those beginner questions. If a question was valid
5 years ago it should still be valid today, but they seem to forget what it's
like to be a beginner.

------
mcguire
I'm a little unclear on why Bob Martin gets as much coverage as he does.
Everything I've read by him has been a mixture of things-that-might-be-a-good-
idea-if-you-don't-go-overboard and his own personal opinions, both presented
in such a way as to look like Eternal Truths of the Universe.[1] Sure, he's
been around for a while, but so have I and it seems our mileage has varied.

[1] See, for example, [http://maniagnosis.crsr.net/2012/03/clean-
coder.html](http://maniagnosis.crsr.net/2012/03/clean-coder.html)

~~~
Reefersleep
I'm with you. After hearing him mentioned numerous times in various contexts,
I gathered he was some sort of sage guru. Then, I read one of his articles for
the first time, "'Interface' considered harmful[1]. I found it rambling and
the style to be a bit condescending - and, I found out after reading this
piece, I absolutely deter the "X considered harmful" premise[2], which is
probably the main instigator in giving the article a condescending feel, along
with the acted-out teacher-pupil discussion. I'm a peer, not a pupil. The
tweet seems short-sighted and destructive to me as well - not the action of
some wise, caring "uncle".

[1] [http://blog.cleancoder.com/uncle-
bob/2015/01/08/InterfaceCon...](http://blog.cleancoder.com/uncle-
bob/2015/01/08/InterfaceConsideredHarmful.html) [2] My feelings are in line
with "“Considered Harmful” Essays Considered Harmful" (The title being the one
exception to the rule : )
[http://meyerweb.com/eric/comment/chech.html](http://meyerweb.com/eric/comment/chech.html)

------
jandrese
If you are expressing interest in functional programming the community is more
than willing to lend a hand.

Where the reputation comes from is when someone talks about some problem they
have in an imperative language and some Functional Programmer swoops in to
tell them how it wouldn't be a problem if they simply rewrote their entire
project in Erlang or something.

There is also a perception that functional programmers aren't willing to
discuss potential downsides to functional programming. Haskell is the last
language you'll ever need for anything you ever want to do and it is perfect
for all purposes from embedded systems all the way up to business applications
and realtime games.

------
cpursley
You can't change functional programmers.

~~~
PeterWhittaker
Oh, sure you can, you just need a side-effects monad. They're plentiful in the
hardware world....

~~~
danieldk
A 'side-effecting' monad is also pure ;):

[http://chris-taylor.github.io/blog/2013/02/09/io-is-not-a-
si...](http://chris-taylor.github.io/blog/2013/02/09/io-is-not-a-side-effect/)

------
steego
I have mixed feelings on this. I have a history of projecting arrogance when
it comes to new programming paradigms. I've been doing it since the mid 90's
when I used to arrogantly deride non object-oriented programming. How could
you not abstract everything as objects? Can't you taste the dream of software
reuse? A few years ago I was arrogantly deriding object-oriented programming
(The C++/Java variety, not Smalltalk).

It's hard not to be arrogant, especially when you feel strong conviction about
some ideas. You actually feel like you need to wake people up from their
intellectual slumber, so you'll find yourself saying things that draws
attention. Getting your ideas attention is good, right?

I've had my ass handed to me on more than one occasion and my arrogance
pointed out as well. It's been an important lesson because its seared lessons
remind me to present ideas with empathy.

However, I want to live in a world with a diverse set of opinions that
tolerates fundamentalists and their fundamentalist/reductionistic ideas on
things like functional programming. Intellectually speaking, I think we need
all kinds. We need people who are stubborn and will completely commit and
defend ideas and we need people who try to unite ideas by solving what they
see to be false dichotomies.

 _I think it 's important to call out arrogance when you see it, but branding
a community as arrogant is obtuse and disingenuous._ It can be a useful act
that forces a community to flush out bad actors, but it also has the effect of
conflating ideas with bad actors.

~~~
AnimalMuppet
Take Haskell, for example. It's good that Haskell is so single-mindedly driven
to pure FP with no compromises. The only way we see what's at the end of that
road is if some people drive it to the end. That's a good thing. Even if
they're wrong, they're exploring the space, and leaving a clear trail.

It's not wrong for them to be advocates, either. "This set of problems goes
away if you do it our way." Well, if they didn't repeatedly shout that in
various forums, I probably wouldn't know that FP was a viable option with some
benefits.

What's wrong is when some of them call everyone else unenlightened for not
being on their road, when some of them insist that their road is the only
possibly right road, when some of them state that any other choice is stupid.
_That 's_ arrogant. It's not the whole community, but it's some.

------
ender7
I must be missing some context here, because the whole article seems to boil
down to "someone I like said something I don't like :(". He spends a fantastic
amount of time scolding Martin for disagreeing with him and almost no time
actually commenting on whether the accusation is really true. Wha?

~~~
peteretep

        > the whole article seems to boil down to "someone I like
        > said something I don't like :("
    

You must be new here, and by here, I mean The Internet.

------
cgearhart
The thing is, some functional programmers _are_ arrogant. I really like the
understanding that comes from learning a functional language, but I've never
fit in among the die hard folks who believe that it's functional or nothing.
As a functional moderate, I've been maligned at times and in particular by the
functional faithful -- which comes off as arrogance.

In an interview once, I was asked what defines functional programming. After I
provided an answer I thought was reasonable (function composition,
statelessness, immutability), my interviewer politely responded to my obvious
ignorance with a few corrections like, "you forgot first class functions!".
The tight smirk on his face was as if to say, "Ha! Gotcha, n00b!"

I think a lot of functional advocates are out to prove that it's _better_ than
imperative and other paradigms, but it ends up coming off like a forced sports
rivalry. What the hell does "better" mean, anyway? Pick a good enough tool for
the job and ship something.

~~~
turkeysandwich
I don't think there's any reason to think that functional programmers are more
arrogant now than advocates of new programming paradigms were in the past.

You could call them architecture astronauts:
[http://www.joelonsoftware.com/articles/fog0000000018.html](http://www.joelonsoftware.com/articles/fog0000000018.html)

~~~
cgearhart
I wouldn't really call functional a "new" paradigm...

It's fun learning new tools and tricks, too, so I don't mind advocacy and
outreach. But many folks in the cult of functional present it as a panacea --
"If only," they lament, "everyone would use _functional_ languages, we
wouldn't have all this terrible software because functional languages
eliminate entire classes of bugs!" and other tropes. Even if all the hype is
true, that doesn't mean that the functional model of computation is the best
(easiest to grok, maintain, or whatever) way to solve every problem. There is
room for a variety of ideas and programming models, and I'm glad functional is
one of them.

------
jandrewrogers
The phenomenon is not unique to the FP community by any means, though it is
more prevalent there in my experience. I've seen it in OOP, C, Java, et al
communities as well and I think it is more attributable to how people interact
with the language philosophies than the languages themselves.

In my opinion, the phenomenon arises from a simple fact: all of these
programming models are terrible for writing some significant subset of
software functionality. Just because you _can_ write any piece of software in
FP, OOP, etc does not mean it isn't an objectively poor engineering decision
some of the time. Nonetheless, I frequently see assertions in various
communities that these apparent deficiencies are really due to insufficient
cleverness on the part of implementors rather fundamental weaknesses in the
model for the use case, while ignoring real-world engineering constraints like
cost, performance, and maintainability.

The perception of arrogance, or lack thereof, largely reflects the willingness
of a community to acknowledge the fundamental weaknesses and deficiencies of
their chosen programming model when interacting with people outside the
community. Too often, people that question the objective limitations of a
particular model are told that if they were smarter or better educated, they
would not worry about those limitations. For obvious reasons, this comes
across as arrogant.

One of great changes in programming languages over the last 20 years is the
extent to which they have become relatively model agnostic and allow you to
switch models fluidly. FP remains one of the last bastions of single model
purists in my experience, which may explain why they are perceived as more
arrogant by outsiders.

------
JustSomeNobody
Some programmers are arrogant. It has nothing to do with Functional or OOP or
Lisp or anything. Some programmers are just arrogant. Period.

I can take this even higher. Some _people_ are just arrogant. It really has
nothing to do with programming. They are just arrogant.

Don't play with those people. Play with nice people.

~~~
s73v3r
Unfortunately it seems as if there is a higher concentration of those people
in some communities. Making them difficult to avoid if you want to use that
tool.

------
tdees40
Maybe! But proving an assertion like "Functional programmers are more arrogant
than OOP programmers" or whatever is probably impossible. So here's my
contribution to this debate: I write Haskell in my free time, and I'm not
great at it, but if beginners ever need anything, e-mail me and I'll do
everything I can to help. So for my part, I'm going to be non-arrogant and
super-helpful and damn the rest.

------
moron4hire
I kind of scratch my head at the concept that there is even a "functional
programming community" [0], let alone that it is "full of arrogant jerkfaces".

As a target, "all those jerks over there in the XYZ tent" is a really crappy
one. There's no tent. There's no one group of people who represent the
interests of a certain methodology. "We" can't even get people who are
ostensibly _in_ the group to agree on what the methodology consists, and you
want to make a target out of "us"?

There are certain pockets you can talk about. "The developers of XYZ
programming language who frequent this particular subreddit." Maybe. You're
still probably missing the vast majority of practitioners of that language.

And what is the end result of this supposed to be? If we can even clearly
define a target, what then? Throw away the methodology because of it?

[0] substitute Functional for OO or imperative or what have you.

------
brlewis
tl;dr version: Functional Programming's reputation for arrogance does not
match the author's own experience, having been welcomed from the time he first
showed interest.

------
jrcii
I've spent my life learning technology from others. More often than not I've
found the IT community to be hypercritical and unfriendly. This appears to be
somewhat mitigated with older crowds, which leads me to believe that it may
just be a maturity factor. The root cause, as best I can tell, is that people
who have heavily invested in technical fields evaluate their self worth, and
maybe their distinguishing value to society, in terms of their knowledge
relative to others. So a new person who is not at their position, but climbing
their way towards it, is a threat. I may be wrong but what I am certain of is
that spending your life dealing with IT people online is not for the faint of
heart.

------
roneesh
Rather than another social debate on coding, let's get to the real problem
with functional programming: There are not enough good resources for it.

It doesn't matter as much if FP'ers are arrogant if you can just learn it
properly without them.

I've read blogs, academic papers, chapters in books and more about FP, but
I've really yet to find a clear, concise and mutually agreed upon starting
point. The best example so far has been a hard to find essay from Recurse
Center. Perhaps one exists, but the fact that my searching didn't yield one
(and I have searched) might be a more substantive reason for why more people
don't FP.

~~~
jdeisenberg
This is exacerbated by language choice. Clojure, OCaml, Haskell, Erlang,
Racket...? I'm not sure about materials for teaching FP in the abstract, but
Racket appears to have a very good ecosystem for beginners; see the "Learning"
section at [http://racket-lang.org/](http://racket-lang.org/) Also,
[http://www.bootstrapworld.org/](http://www.bootstrapworld.org/) is an
interesting project.

------
AnimalMuppet
> 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?

It's not how welcoming FP people are to newcomers. It's how condescending and
condemning some FPers are to those who are outside FP. "You're
unenlightened/stupid/incompetent/wrong if you don't do it _this_ way." Yes, I
have heard that attitude, here on HN, more than once.

Immutable is good. It's not always the right answer, though. Some FP advocates
don't seem to get that, and assume (and state) that everyone else is wrong to
ever do it any other way. _That 's_ arrogant, because it assumes that those
who choose some other way cannot possibly have valid reasons.

------
88e282102ae2e5b
Take videos like this:
[https://www.youtube.com/watch?v=ZhuHCtR3xq8](https://www.youtube.com/watch?v=ZhuHCtR3xq8)

The guy basically goes on some pseudo-mathematical journey that has only a
tangential relationship with programming. "It's easy to understand!" he claims
multiple times. And it was! I understood everything he said. But I had NO idea
how to apply anything he said to my application.

And so it goes with virtually every article I've ever read about functional
programming. The truth is out there, but it's hidden in such a dense forest of
obfuscation that I'm not sure I'll ever know what a monad is.

The search goes on, but I'm afraid all I'll ever discover is yet another blog
post where all the functions are named f(), g() and h(), or something about
prime numbers.

So I suppose arrogance may be assumed from seeing this concept explained so
badly so many times. It's like people who understand functional programming
are gatekeepers and do such a horrible job at letting people in that it seems
like we've been locked out on purpose.

~~~
sklogic
You know, it's sort of like a werewolf bite. It'll hurt first, then you'll
turn and start writing blog posts about f(), g() and h(). And you'll really
struggle to understand the complaints of the uninitiated.

------
brudgers
For some context on Martin's comments his talk on how arrogance effected
Smalltalk is probably relevant:

[https://www.youtube.com/watch?v=YX3iRjKj7C0](https://www.youtube.com/watch?v=YX3iRjKj7C0)

and probably worth watching if you enjoy Uncle Bob's soulful stylings and are
interested in his thoughts about programming language communities.

------
meeper16
Arrogance as an attribute of a software engineer? Naw...Say it ain't so!

------
fecak
As a bit of an outsider (recruiter) that talks to people in various areas of
programming, there does seem to be some perceived hierarchy in programming
that is somewhat related to language communities, and I sense it quite a bit
on HN. I can see how functional programmers could feel that what they are
doing is more complex than what non-FP'ers are doing, generally speaking.

Based on how people reference complexity, I'd think FP languages would be
considered to be at the top of the language community hierarchy. Even within
FP, I don't feel it's a stretch to think many view Haskell and Lisps "above"
say Scala. On HN, we may see more about Rust than we would out in the wild.

I do find that FP communities tend to seem inviting to at least some other
language communities and are eager to introduce the FP world to certain other
groups (say Python, Java) but perhaps less likely to other language
communities (PHP).

------
kazinator
What, there are arrogant people on the Internet? Say it isn't so!

The fact that some user of a functional language is arrogant has no bearing on
whether you should use it for your project.

If you think that it does, then maybe you shouldn't be a programmer, for two
logical reasons. One is that it is not logical to think that, and programmers
have to think logically. The other reason is that for any stack of development
tools, we can find someone who arrogantly advocates it, so if the existence of
arrogant evangelists is a problem, you must necessarily be discouraged to use
anything at all.

What car do you drive? If it's any good (and even if it isn't), there are
owners of the same car who arrogantly believe that they are better than
others. So, sell it: you don't want to be associated with them!

~~~
jmduke
This can be extrapolated to say "the community which uses a language should
not have any bearings on your decision to use that language", which to me is
crazy if only for pragmatic reasons -- a strong, welcoming community has tons
of observably positive effects on my experience with a language (between docs,
third-party libraries, SO/IRC presence, etc. etc.)

~~~
kazinator
No, it can't be extrapolated that way, because the community which uses a
language is more than just attitude (arrogant versus humble); the community
has a productive aspect, like producing tools, libraries and such. Just the
basic attribute of the _size_ of that community could be significant.

Some languages with a welcoming community nevertheless have arrogant
evangelists.

You can make your own language and use it; where is the welcoming community
then? And what if you're arrogant? :)

------
kozukumi
I have always found the Haskell community to be very friendly to newbies. They
have a great channel on freenode.

However I do agree that their can be a lot of arrogance in the FP world.

This is actually true of quite a few languages though. C (i.e. kernel) devs
can be complete assholes towards people wanting to learn but are finding
searching for things frustrating.

On the flip side the C and C++ communities, especially /r/cpp,
/r/c_programming on reddit[1], are fantastic. Very newbie friendly with a lot
of expertise there. Stephan T. Lavavej (/u/STL), the Microsoft STL maintainer,
is very active on /r/cpp and responds to many questions asked of him.

[1] Also check out /r/cplusplus, /r/c_language, /r/cprogramming and /r/cprog

------
saosebastiao
Really, it's just Haskell. I've participated in pretty much every major FP
community and the only place I find arrogance is the Haskell community. Never
have I found any other FP _community_ to be arrogant apart from an occasional
programmer or two. But Haskell is different...non-arrogant programmers are the
exception. And as far as I can tell, those that are not arrogant are also
exceptional in that they have actually produced something of merit, like jgm
for example.

~~~
nahiluhmot
I have had the opposite experience in the Haskell community. Hell, /r/haskell
even started a AMA for new Haskellers[0] this week, and all I see is pleasant
replies.

[0]
[https://www.reddit.com/r/haskell/comments/3cfax3/new_haskell...](https://www.reddit.com/r/haskell/comments/3cfax3/new_haskellers_ask_anything/)

------
unics
In my humble opinion I suspect that the only fields more arrogant then the
computer field are law and health fields. Then of course you can throw in the
engineering and political fields. Have I missed anyone.

I seem to be cut from the old hacker mentality that all information should be
shared and the collective minds can improve it to perfection. I have
increasingly found though a mentality of "ask me no questions and I'll tell
you no lies".

I guess my being a narcissist isn't what it used to be.

------
rubiquity
A person (Uncle Bob) who makes a nice living off of selling cyclicle baloney
on OO best practices to OO programmers thinks FP programmers are arrogant? Say
it ain't so!

------
gdubs
I posted Andy Matuschak's Functional Swift talk on another thread, but it's
worth posting here too -- it specifically addresses how teams can introduce
Functional concepts in a way that brings everyone on board, without alienating
anyone:

[http://2014.funswiftconf.com/speakers/andy.html](http://2014.funswiftconf.com/speakers/andy.html)

(Andy leads the mobile team at Khan Academy, and worked on UIKit at Apple
before that.)

------
danieldk
It's pretty much like any programming language: you have people who see a
language as a tool and people who have a language as a religion.

In the latter group, there is often language arrogance. But it applies to any
language. How often haven't we heard "that's not a problem with Go, just use
it longer and you will understand".

Now I wonder if there are still any arrogant COBOL believers around ;).

------
marknutter
There is no excuse for being arrogant or an asshole. In my mind it's as bad or
worse than physical bullying. Sure, you may be more knowledgeable than someone
else in your particular field of expertise, but you were once completely
clueless. Being an asshole to people who are trying to join your community is
like cutting your nose off to spite your face.

~~~
gagege
Did you read the article?

------
hartator
I've heaard a lot about functional programming but I still not getting how it
should be superior to object oriented? I feel OO brings to the table concerete
best pratices (everything should be an object, object have state, class
defines object bejavior, class inheritance, objects encapsulation...) that's
broken by functional.

~~~
escherize
Hi! I have been a programmer for a couple years and started picking up clojure
after watching a few of rich hickeys talks. This is the one that best
satisfies your question, imho:
[http://youtu.be/-6BsiVyC1kM](http://youtu.be/-6BsiVyC1kM)

------
barce
Where's the data? If the data is the tweets cited and googling 'Functional
Programming Arrogant', then it's definitely a hasty generalization (the
community is open) of a hasty generalization (the community is arrogant).

------
frik
Seem to be true, even mentioning JS in a FP thread means downvotes:
[https://news.ycombinator.com/item?id=9826659](https://news.ycombinator.com/item?id=9826659)

------
sudioStudio64
I think that FP gets a lot of coverage on this site because it's an
interesting topic to lots of us...even though most of us won't ever even
attempt it beyond a few samples.

That being said...SICP 4 LIFE!

------
sklogic
It's just a way too easy to take confidence for arrogance. It does not matter
if this confidence stems from an illusion or from some real deeper
understanding of how to hack things.

------
emergentcypher
Programmers? Arrogant? You've made the discovery of the century!

------
boobsbr
more like: Programmers Are Arrogant

~~~
eropple
Does that make it somehow better or not worth fixing?

~~~
moron4hire
No, but it potentially includes the original speaker of the "<whatever>
programmers are arrogant" idea and will hopefully make them reflect on what
possible ways they could be improving their own sphere of influence. "Let he
who is without sin casteth the first stone" and whatnot.

------
adultSwim
News at 11: hyperbolic Twitter negative comment.

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

