
Dear JavaScript - johnwards
https://medium.com/@thejameskyle/dear-javascript-7e14ffcae36c#.vu0ksgif7
======
fusiongyro
I don't want to distract from the main thrust of the article, which was that
we should be decent to each other even with our criticism, but I think both
his examples (Babel 6 and Angular 2) had something in common that lead to a
lot more anxiety: they changed the essence of the software in a way that a
major version bump is not enough to communicate.

I'm speaking especially of Angular 2 here. It's essentially a completely
different framework. You don't expect going from Postgres 8 to Postgres 9 that
the underlying query language is going to be switched out for a different one.
Regularly communicating with your users, as Angular and Babel did, only
reaches the engaged part of the community. A lot of workaday programmers are
not that deeply engaged. You're just moving their cheese, and it makes them
mad.

A better approach is to spin off a new system and give it a new name. This is
what happened with Express and Koa, and it gives you a way to gauge whether
people actually want the change you're making or not. I predict Angular 1 is
going to be the Windows XP of front end development: lingering on for much
longer than anyone expects. Slow and principled change is not a common thing
in Javascript-land but it is what legions of software engineers expect. A lot
of front-end development, like it or not, is being done by full-stack
engineers or other engineers who are not front-end developers exclusively.
Asking your echo chamber if they like your ideas is not really a sufficient
sounding process, especially if you're making a deep cut.

~~~
thejameskyle
The change in Babel 6 was this:

    
    
       $ npm install babel-cli
       $ babel src -d lib
    

To this:

    
    
       $ npm install babel-cli babel-preset-es2015
       $ echo '{ presets: ["es2015"] }' >> .babelrc
       $ babel src -d lib
    

It really wasn't that big of a change.

Also, we did give it a new name. It used to be 6to5, and we changed the name
around the intention to make it more generic. Which Babel 6 was the
culmination of.

As for communicating with the community. Yeah, we can't address everyone at
once or even reach them all. We could shove it in their face (and we do) and
still a significant portion would still ignore us (and they do). There's not
much we can do about that. But they shouldn't come to us and say that we never
said anything about this, because yes we did.

Also, the article I referenced about Angular 2 was not talking about the
transition from Angular 1 to 2. It was talking about ng2 as its own thing,
criticizing it's design more than anything (just in a really shitty way).

~~~
c3RlcGhlbnI_
Yeah, I don't think a name change would have fixed this case. Here you were
just wrong. You failed to predict the impact of such a visible change and as
such did not implement the change in such a way to minimize impact or use an
appropriate migration plan so as to not surprise users.

Sadly the users most likely to be inconvenienced by a change like that are
also those with the least knowledge of the product(like if you don't know what
babel actually does, you aren't going to understand why the cli stopped
working or why you need this new config file to make it do something). That
leaves them frustrated and angry but with a poor understanding of why and what
adequate solutions would be. There is nothing you can do about that, asking
the community to be nice isn't going to help because most of your users don't
think they are even in a community.

The only things you can do are try to anticipate them a bit, and to try and
count the criticisms but ignore their contents(and search yourself for the
deeper cause). Luckily the first part is sort of easy for JS projects because
most of the active tooling development in JS is on things that have been done
many times before. In this case you could have just looked to gcc and wondered
for a bit why they still ship with --std=gnu90 by default, despite how
maddening that must be for all the developers working on new features that go
underused as a result. You could have looked at all of the other software that
is stuck dragging forward dumb configuration systems with complicated defaults
and layers of precedence instead of just asking users to fill in a few config
fields on first run.

So I do want to say that I am so sorry on behalf of your users, and I really
appreciate the work that you do. However that was a real mistake with babel
and a big part of improving the interaction between you and your users
unfortunately falls on you.

~~~
pfranz
This is what makes open source (and a lot of volunteering) really difficult.
If you look at a sibling post, one reason given was, "Just tried to use
hyperbole to bust the Javascript echo chamber." I think that's true for many
of the egregious examples, but it still hurts and isn't fair the people
working on the project.

The lines get blurry, XP has a business case for dropping support, Google (and
GNU) are decently funded I imagine. I'm not sure how much his work at Facebook
and his contribution to open source overlap, but it's not fair to be outraged
or make demands if you're not paying anything--especially if this is all work
done own his own, for fun.

Hell, I work in an industry where we pay for expensive software but don't have
a venue to complain about bugs or feature changes because they don't make
themselves accessible. We could pay 10x more money and get a support contract
where we can yell at them, I've worked at places that do, and they likely
won't address your issues. Pay 100x more and they'll write a custom version
for you. With OSS, many times, we get this for free.

------
nkw
I was commenting to a colleague the other day how amazed I was at the sheer
quantity of github "issues" that I was seeing posted to a few popular open
source repositories that were rants about why feature X wasn't available yet
or a priority yet, or demanding that someone walk them through some
installation issue because the poster couldn't understand (or didn't read) the
README. None of the people that posted this stuff appeared to have ever
contributed to that project (or any project), but thought they were entitled
to what were essentially support requests or re-tasking of developers to meet
their demanded schedule.

Our discussion eventually thought it was due to two things: 1) Github, while
making the open source process visible and easy to use for many, also makes
the process pretty open and barrier free to people who may not yet have the
technical (or social) ability to meaningfully contribute to a project; what
once would have required posting to a dev mailing list is now just a couple of
clicks; and 2) a cultural mindset that some people seem to have that free or
open source software is some kind of entitlement (or at least due to
communication issues, and the ambiguity of the written word on the Internet
that is how I thought it came off). I think the sheer volume of freely
available amazing software has caused some to forget the whole reason we have
this stuff is someone somewhere spent a lot of time working on it and then
decided to give it away.

I don't know if this is really a javascript thing, but I think it manifests
itself there more than others simply because javascript might be the first
place a lot of people start in their career/learning.

~~~
detaro
regarding your first point: often there doesn't seem to be a dedicated support
channel/community. Mailing lists are less and less popular, if one exists its
web interface is likely a long way behind GitHub. There are no forums. Some
languages have project-independent channels (e.g. message boards for python
users will try to help you with whatever library you're messing with right
now), but they don't exist for all ecosystems and are shrinking. Stack
Overflow has a low tolerance to badly asked questions and a reputation for it
(and probably killed the message boards that dealt with them before).

Initially, it makes sense that questions go to Github (public, no extra
infrastructure needed, no community yet), but at some point they have to be
moved. Even a %project-questions repository might help, if enough non-core-
devs take care of it.

EDIT: to add to the last point: if a core contributor has to click the "close
issue" button on a question that's a problem. Either give community members
the power to do so (at least some are going to feel honored by that, a great
motivation), or push questions to a channel that doesn't have that notion.

~~~
moosingin3space
Project Q&A sites, subreddits, and IRC channels are a pretty good solution to
this (based on my experience with Rust for the latter two), as at least it
separates "support" from "issues". Doesn't fix toxicity, that requires
consistent and effective moderation, another thing Rust does well.

~~~
gabeio
I agree subreddits and IRC, can be moderated by users who don't need to
directly have repo access, sort of an abstraction, unlike how github repo
members/collaborators would, can be a huge assist to eliminating that
toxicity. It even has the potential to be handled before the negativity ever
gets to those who have so much going for the project, unlike github issues
currently which really require the collaborators who have usually contributed
a lot to the project, to directly mitigate the toxicity there. I think it
would be a great asset if github added the ability to give certain
collaborators access to issues only which might aid in fixing this issue
allowing there to be sort of moderators/support users who love the project but
maybe are better at giving back by moderating issues more than contributing
code.

~~~
moosingin3space
Sort of like gitlab's Reporter role?

Also, the biggest problem with IRC/subreddits with a dedicated community team
is that it takes a _long_ time for many projects to reach the point where this
is feasible. Rust is large enough it's fine, but many small projects (like
what's common in the JS community) will never get enough people to dedicate
some of them to "community management".

~~~
gabeio
I think so I haven't used gitlab enough. Yeah libraries do need to become
large enough but I think angular2 is ~19k stars & 2k watchers which is more
than expressjs/express watchers but less stars, but it depends because I do
sort of this role with expressjs/session which is pretty small 1-2k stars I
try to help with what issues I know how to and to get all the information from
the users to help debug. We have only had one issue (that I know of) of users
negatively critiquing the library.

------
jasode
_> But when someone starts to insult me in mock my hard work, when they
criticize me and my work in a way that is extremely negative, it gets to me._

That seems to be the essence of his entire essay. He wants people to be nicer.
Yes, criticism is often necessary and often motivates progress, but the
criticism should be nicer.

Well, that's an ideal but his lament isn't limited to Javascript specifically.
Nasty complaining is part of the _universal human condition_. Instead of _"
Dear Javascript"_, it's more like _" Dear All of Humanity"_ ... stop being so
mean-spirited.

In the same vein, we could generalize BS's quote:

 _" There are only two kinds of languages: the ones people complain about and
the ones nobody uses."_ -Bjarne Stroustrup

... to ...

 _" There are only two kinds of github projects: the ones people complain
about and the ones nobody uses."_ -every maintainer

~~~
Mouq
Ok, but he's specifically calling out communities that reward negative
behavior rather than calling it out. I mean, are you being serious right now?
There's a difference between "boo hoo everyone's so mean :'((" and "hey, there
are community issues that we should try to address", and that's pretty
explicitly the point of the article.

~~~
jasode
James Kyle wrote:

 _> There’s a lot of these “sub-communities”, places like /r/javascript and
Hacker News that often reward negativity more than positivity._

and you write: _" hey, there are community issues that we should try to
address",_

Ok... so exactly _how_ do we address it? Do we repeat, _" From now on, let's
all be nicer with more positive energy and feedback!"_

Ok, now that we've done that, is the problem solved? Why not?

You see, negativity in complaints about others' work is universal. Before the
internet, scientists had been slinging mud at other scientists' work in
prestigious journals. During the heydays of Usenet we had nasty Lisp debates.
And now, we have have rants about Babel6 and Angular2 that's a killjoy for the
maintaners. As Captain Louis Renault would say, _" I'm shocked gambling is
going on in here!"_

On a related note... I recently read about autism and a book discussed some of
the debates of parents caring for an autistic child. You'd think that an
environment like that would foster the ultimate empathy and positive feedback
(compared to Javascript projects) ... but no.... some parents are quite mean-
spirited in criticism of other parents' therapy methods. To think we can
somehow "solve" the problem of Javascript programmers' negativity about OSS
projects seems naive.

~~~
GavinMcG
There are nice communities out there. It seems more naive to me to think that
we might as well just throw our hands up in the air than to think that we can
identify ways to move ourselves forward.

You've also shifted your criticism here to "Ok, but how?" from the original
criticism that sounded like "Well, humans suck. Boo hoo."

So, here's one answer to how: as I am doing right now, we can encourage others
to be optimistic about growing and developing ourselves and our communities
into better people.

Here's another: as I am about to do, we can pinpoint unhelpful claims that
hold us back from improvement rather than moving us forward. Your comments so
far have largely been the former, in that they treat the people the article's
author criticises as though they couldn't behave any differently. One key step
is adopting the belief that people, including the people who have been really
nasty so far, can in fact choose to behave differently.

Here's another: We can be vocal about the importance of maintainers standing
up for respectful communication within their communities. We can create and
spread resources that help empower people to do this. We can institutionalize
roles such as "community maintainer" whose job revolves less around code and
more around discourse.

These are coming off the top of my head. So on that note, here's another: we
can encourage people to do one more thing before posting a comment or article
– check in about whether what they're saying is truly constructive, and
redirect their efforts if not. I'm sure you could have come up with some of
these approaches, and I'm sure you could come up with more that I haven't
thought of. But you need to push yourself to try. You need to push yourself to
get better. And the rest of us need to be here to help you and each other and
everyone else do just that.

~~~
jasode
_> You've also shifted your criticism here to "Ok, but how?" from the original
criticism that sounded like "Well, humans suck. Boo hoo."_

It's not shifting positions. My 1st post was general commentary on JK's post.
My 2nd post was asking Mouq to clarify his "solution" since he didn't actually
state a concrete solution.

 _> So, here's one answer to how: as I am doing right now, we can encourage
others to be optimistic_

Yes, did you notice that I _already made that suggestion_ in my post that you
replied to and you just repeated it?

~~~
magicalist
> _> So, here's one answer to how: as I am doing right now, we can encourage
> others to be optimistic_

> _Yes, did you notice that I already made that suggestion in my post that you
> replied to and you just repeated it?_

Hmm, let's see...

> _Ok... so exactly how do we address it? Do we repeat, "From now on, let's
> all be nicer with more positive energy and feedback!" Ok, now that we've
> done that, is the problem solved? Why not?_

yeah, no, that's not the same thing at all.

~~~
jasode
_> , no, that's not the same thing at all._

Are you being literal? I wasn't saying that "repeated" meant lexical equality:

    
    
      string.compare("more positive", "optimistic") == TRUE
    

Instead, I meant this:

    
    
      semantic_intent("more positive", "optimistic") == TRUE
    

It's naive to think GavinMcG's "solution" of disapproving others negativity
hasn't already been done thousands of times before across other disciplines
and other forums including Linux/Lisp/C++/PHP/physics/autism/etc. Yes, nice
communities do exist (often because of heavy-handed moderation/censorship) but
that's orthogonal to the inevitable formation of _other uncensored
communities_ that freely share negative criticisms. Therefore, the _reasons_
that motivated JK's original post will _always_ exist.

~~~
GavinMcG
Another big difference is that I'm not advocating for us to "repeat" that we
should all be positive. It's not about public proclamation – it's about
addressing individuals and their individual acts. That's what the communal
discourse is made up of. Like you're saying, simply shouting "let's be nice"
obviously doesn't work.

I'll add another thing to my list of suggestions: be really deliberate about
educating people on the principle of charity. Instead of assuming that the
other person is dumb/shortsighted/etc., assume that you're not giving their
thinking enough credit.

> that's orthogonal to the inevitable formation of other communities

So what? Drive the downers out of JS-land, or whatever community you care
about. You had been saying that even that shouldn't be bothered with. But if
it can be accomplished, who cares if they all go off to learn Brainfuck, if
that's the only community that will accept their behavior?

~~~
jasode
_> Drive the downers out of JS-land,_

This is not possible.

When you previously mentioned "nice communities", I thought that meant
specific javascript forums. Now I see you meant to drive the undesirables out
of entire Javascript language completely and force them into another language.

 _> You had been saying that even that shouldn't be bothered with._

I've _never_ said this. I've never suggested that people shouldn't strive to
have well-behaved communities that encourages constructive feedback. In the
forums I moderated, negative rant posts were not allowed and deleted.

However, I see the confusion in interpreting my posts now. You and Mouq are
focused on the "making a better world" angle. My posts were describing
something else: the build up of anger about <topic> will always exist to
frustrate people like JK _regardless_ of the efforts to make a friendlier
community. (E.g. see multi-decades history of discourse about
C++/Java/Lisp/etc/etc)

~~~
GavinMcG
> Now I see you meant to drive the undesirables out of entire Javascript
> language completely and force them into another language

Not at all. I misinterpreted what you meant in your concern over them forming
other communities.

------
pavlov
_I’ve always been advised to avoid these “sub-communities” like /r/javascript
and Hacker News. Maintainers say they are filled with assholes who don’t know
what they are talking about, angry idiots shouting at everything and everyone,
cesspools, giant piles of trash burning in the wind._

Is HN really that bad? I mean, it must be, if people maintaining popular open
source projects think so... But why does it feel much more useful to me than a
"pile of trash burning in the wind"?

I guess my experience as a commenter is so different because I've learned to
tune out the negative stuff and it's not aimed at me.

~~~
OskarS
Check out this comment from one of the devs behind Homebrew from HN 10 days
ago:
[https://news.ycombinator.com/item?id=13035438](https://news.ycombinator.com/item?id=13035438)
(this was in response that he might be a good target to sue over putting
Google Analytics in Homebrew).

Yes, we need to treat our open source devs better. HN is not innocent.

~~~
pavlov
Holy shit. That's just insane.

It feels like some people treat open source developers like government
employees. Both provide a seemingly "free" service, and when you're not paying
it's easy to ask for more and get upset about trivial things. (Of course
neither group deserves this kind of thing.)

~~~
endisukaj
> Both provide a seemingly "free" service

I'd argue that open source maintainers provide a free service. Government
employees do not.

~~~
pavlov
Many prominent open source projects are supported and often initiated by
corporations. I imagine Google pays the core Angular team quite well.

~~~
endisukaj
Of course. But most of the time users are not paying the maintainers whereas
with government employees you are paying them through your taxes.

~~~
emn13
Well, that's hardly any different to google. You have no control over the
details of those taxes. If anything, the advantage you grant google is likely
more direct and quite probably more costly if you're comparing apples to
apples. It's just really hard to compare those.

Don't forget, google gains quite a lot from giving away software like this,
and some of their gain (in the form of control) may well be a cost to others -
and it's not a zero sum game, so it's anyones guess whether it's a net
positive or negative (even though that seems unlikely).

Similarly, you talk of the paying taxes as if this were some net-negative
cost. There too this isn't a zero sum game - just because you distribute the
costs but don't account for the benefits doesn't mean it's not net beneficial
to you. The government is even larger than google (and indeed intertwined the
the semi-fiction of currency), so "paying them" doesn't really mean the costs
are much more direct than they are with granting google influence of the JS
ecosystem.

Even if through voting you could choose the cease to "pay" for the government
employees, the consequences might well be far-reaching and impact the currency
system (hence "pay" in quotes), so from one point of view you can't with any
reliability choose not to pay, rather, you can choose not to account for costs
accrued by a large civilization. But it's highly questionable whether you can
actually avoid those costs and remain a large civilization.

------
forgottenpass
_It felt like every day I had a notification waiting to be opened about how
badly we had fucked up._

It's interesting that the author phrases it this way, and dove tails nicely
into a thought I've been having about interaction on the internet for a while.
I don't say this specifically to the author, but generically, it's even
something I'm working on being more aware of.

Social tools and other apps have turned notifications into a Pavlovian
variable-interval reward loop. This makes negativity even harder to handle.
But seeing the system laid bare makes it easier to make decisions about.

The notification loop sort of evolved that way with texts, but is also a
purposeful tool of manipulation. We politely don't conceptualize it as
"manipulation" because there is weight to that word, and we don't necessarily
assume the app designer is acting in bad faith. But it's still manipulative.

Think of it like this: Who _needs_ to be able to interrupt you every waking
moment of your life? Then why are you letting a single person more? Disable
notifications, and just set a recurring calendar event to check
email/twitter/whatever.

------
beejiu
I think it works both ways, too. Unfortunately there are some developers that
take any form of criticism as negativity.

Some time ago I discovered a major XSS security vulnerability in a very
popular WordPress plugin (used on over 100,000 blogs). I notified the author
and got it fixed, and published a blog post about the issue 12 months later.
The article itself was entirely factual and described the nature of the issue,
how I discovered it and what the fix was. Unfortunately, the author took this
as a personal attack (the email he sent me made that clear) and I decided to
take the post down.

The thing is, I had actually spend many hours going through every single line
of code to look for other security vulnerabilities. Sure, I hadn't written any
code, and I wasn't the maintainer, but it was still an "open source
contribution" in some sense.

~~~
thejameskyle
I can't read the article so it's hard to say. But if it was just about the
security vulnerability and you weren't calling their software shit, then
that's not what I'm trying to cut away at and I'm not sure why the author took
it so personally.

------
atemerev
Dear James,

I understand that hearing rants about your brainchild that took so much hard
work is hard and depressing. I was in your shoes, too. And being a head of
popular open source project is very emotionally unrewarding, to say the least.
And thank you for your hard work — like nearly every front end developer out
there, I used Babel, and it did it job, eventually.

However, I am one of those people who think that Babel6 is terrible, that it
"broke the web", and it marked the beginning of the entire JavaScript fatigue
era. Babel6 transition took three days of my life, filled it with misery and
rage, lost me a customer, and led to my desire to never touch JavaScript again
if I can help it. (I moved to ScalaJS eventually).

I ranted about it, too. Like nearly everyone else, I forgot that there are
live people behind every project, with their dreams, hopes and justifications
for every decision. I didn't want to attack you personally — I just vented my
(very real) rage against Babel6 itself, without thinking anything about its
author. So, well, nice to meet you.

And I still stand by what I said. Despite your good intentions, it is still
terrible, and unintuitive, and definitely not a "something for everyone",
unless frustration is something. And I can't think of any way of fixing it,
except of moving to another stack (which I did). If there were many people
ranting about Babel6 like I did, (and I can imagine), I am truly sorry for the
mental suffering you had to endure.

You are cool. You are significantly more competent developer than I am. I use
your software, not the other way around. And it is free. But Babel6 is still
terrible, and no input from your side can change my opinion. Or perhaps it
could, if you provided some technical justification for what you did. But this
article is the request to stop ranting about your work, as it hurts you.

For that, I am sorry.

~~~
magicalist
> _However, I am one of those people who think that Babel6 is terrible, that
> it "broke the web", and it marked the beginning of the entire JavaScript
> fatigue era. Babel6 transition took three days of my life, filled it with
> misery and rage, lost me a customer, and led to my desire to never touch
> JavaScript again if I can help it. (I moved to ScalaJS eventually)._

Bad news: you are not a special snowflake deserving of attention, the web is
still here and doing just fine, and it was your incompetence that lost a
customer (Babel 5 is _still_ around for use even today).

Many mistakes can be made by open source teams, and something should not be
immune to criticism just because it is open source. But this is a great
example of noise that harms engagement in a community because you want to feel
good on the off chance that lashing out will make someone somewhere feel bad.

Maybe try to learn from a piece instead of trying to be cute next time?

~~~
atemerev
I do sincerely apologize if something I had said sounded offensive to you or
anybody else.

However, I can't help but ask the question: am I the one who resorts to
personal attacks here?

~~~
magicalist
Yeah, that's bullshit.

> _But Babel6 is still terrible, and no input from your side can change my
> opinion. Or perhaps it could, if you provided some technical justification
> for what you did. But this article is the request to stop ranting about your
> work, as it hurts you._

> _For that, I am sorry._

So you get what he's asking (stop the sniping without substance), you're
(supposedly) contrite about it, and yet in the same breath you continue to do
what you acknowledge is exactly that behavior.

Either there's some fundamental disconnect in your mind that you need to
address or you should just say what you mean.

~~~
atemerev
I do not attack or blame the author, I say that the work (Babel6) is no good.
This doesn't imply anything about the author.

You, on the other hand, attack _me_ personally. You don't even say "your words
sound rude" — that I would understand.

Or there is no difference to you?

------
dweinus
I think there is a lot of truth here. I can't help but feel that you just
diagnosed a great deal of the internet, far beyond javascript or dev. We need
better communities and better communication. I wish I knew how to make that
actionable.

~~~
kilroy123
Agreed. I also think this touches upon a larger issue outside of development.

There is something about being behind a keyboard that makes people much
nastier than they would be in real life.

------
kowdermeister
There is no "fix" to this. This is how people work. Some like things some
don't, you have to deal with it or look for a more secluded hobby. If you can
call it a hobby. Maybe behind every angry post there is a frustrated developer
who've thought or been told that XY framework "is-the-shit" and and it will
rock the way he works. Then he tries it and faces a series of problems. One
consequence might be that he feels stupid, inadequate or incompetent. But
there are some who dare to criticize. I thing that's a good thing. The moment
when your mainstream project stops receiving criticism is probably the day
it's dead. And by criticism I don't mean personal attacks (screw those
idiots). By criticism I mean people with constructive feedback. The "angular 2
is terrible" article had plenty of it, besides the title it was a good read
and insight how A2 really works.

If you want to reduce developer frustration, then try these things first:

\- Write a clear scope what your project is about and how you intend it to
used. Many times devs realize that the tool is a bad fit for them only after
attempting to use it many times

\- Write exceptional, up to date documentation

\- Visually display core architecture explanations

\- Provide clear getting started examples that work out of the box

\- Communicate well breaking changes, updates, milestones

~~~
magicalist
Why would a project maintainer be expected to write "exceptional"
documentation, have a clear scope for something they might still be exploring,
give _visual_ architecture explanations, etc etc and we can't expect
developers to deal with frustration like an actual human?

~~~
kowdermeister
These project aim at the bleeding edge so if a maintainer sets the bar high,
then it's expected to keep up with other aspects as well. Your work as a
maintainer doesn't stop when the /src folder is full of code. Then comes the
boring part.

These things change from project to project and if a project gets more
traction other people will join to fill the missing gaps.

We can expect developers to contain themselves, but some just can't. They are
precisely the ones who can't be stopped with any policy. Some are just in a
bad mood and they also have graphomania, some are constructive some are mean.
I think it's fine as is.

------
EdSharkey
I think a bug tracker is where the rubber meets the road. Blog posts people
write or hecklers on forums are potential avenues to take feedback, but a bug
tracker is where you can expect the most actionable feedback.

Since that's the maintainers' domain, I don't see why they shouldn't just
close issues as "will-not-fix" with tags like RUDE or SUBMISSION_GUIDELINES.
If someone is taking the time to file a bug report, and they genuinely want to
see their problem get better, they'll follow the bug submission guidelines and
give you a detailed report. Heck, if they really want to see change, maybe
they'll even file a pull request with a patch. If someone just wants to flame
or be snarky, close their bug and hopefully they'll try again with a more
business-like, respectful post. Never forget, they are coming to you, and the
customer isn't always right even if they are paying you.

It's okay to blow people off who are just in the game to tear you a new one;
life's too short to give them the satisfaction of your care and your craft.
Trust me, the harshest thing you can do to someone like that is to ignore them
completely as they've just wasted their time and energy flaming you. You can
take some satisfaction in that.

------
carsongross
In the vein of "Worse is Better"[1]'s MIT/New Jersey split, my theory is that
the online javascript community reflects a lot of what I would call the San
Francisco/UI Design attitude (in contrast with, say, Java, which reflects the
Palo Alto attitude.)

The SF attitude is more driven by fashion, marketing and art/design world
factors and less by raw commercial or technical aspects. This introduces a lot
of subjectivity and, as with the art world, snobbery, vicious infighting and
out-grouping. Much of the online shittalking reminds me of the various post-
war -isms trying to box out the other groups.

There are, of course, many things going on: the rise of the online troll,
increasing churn and chaos in the javascript community, bifurcation into the
haves and have nots in technology, even the recent presidental election and
the attendant insecurities. But this is what I see.

[1] - [https://www.jwz.org/doc/worse-is-
better.html](https://www.jwz.org/doc/worse-is-better.html)

EDIT: and I should say, I fall victim to exactly what the author describes
when I'm going off on one of my YAGNI react/angular rants.

~~~
qwertyuiop924
I disagree. A lot of technical design goes into JS projects. React is designed
in a Herculean effort to minimize DOM refresh and thrashing. JQuery was built
to fix very real problems: API incompatability between browsers, and extreme
verbosity in common idioms. Babel is a compiler, with all that entails.

~~~
monknomo
The users of these libraries benefit from this herculean effort of very real
programming, but are mostly not the herculean programmers.

The users are the community, not the library creators. And the users are
mostly, from what I see, the arty designy web dev types.

That doesn't take away from the real problems, or the tricky design or
difficulty in building a compiler for the community.

~~~
qwertyuiop924
But the people behind those libraries are _part of_ the community.

~~~
monknomo
Sure, and they drive the direction of the community, but they are also a
miniscule minority

------
juice_bus
I remember reading that Angular 2 thread and walking away disappointed with
the baby-like, nonconstructive screaming. (disclaimer: I'm using NG2 and enjoy
it).

This article has reminded me that there are people behind these projects, even
the ones I don't like.

~~~
Bahamut
In general, even if you don't like some things about projects, it's worthwhile
investing time to see if you can learn from it for down the road. I'm an
expert in the Angular ecosystem, but I experiment with other frameworks to
learn & get the most I can. The author of that terrible Angular 2 article
didn't even try to understand the system he was working in.

As an open source maintainer (UI Bootstrap/ng-bootstrap)/contributor (Angular
1 & 2, Universal Angular, UI Router, Ionic, karma), I respect those who work
on other projects, even if I disagree with approaches.

We need to have less holy wars and more constructive discussions instead, and
demand more from fellow developers to foster this atmosphere. I've been guilty
of using emotional language in the past, but time has led me to mature in this
aspect - it would be nice to see everyone else make this jump as well and join
us in making software better for all.

------
20years
I think part of the problem is junior developers think they need to use these
frameworks for every project, which results in frustration and running around
in circles. They then blame the framework or developers because the framework
wasn't really right for their use case or doesn't give them exactly what they
want.

Maybe the community needs to do a better job at communicating best use cases
for these frameworks.

Are you developing a Gmail type app with multiple devs? Okay, maybe an Angular
type framework is a good option.

Are you developing a simple CRUD app? Probably not the best to use a heavy
framework then. A framework in this case may actually slow you down.

Single page apps and frameworks are not needed for everything. Probably not
even needed for most web apps that people are using them for.

------
nxrabl
What is going on in this thread?

"Just don't come here"

"Just turn off your notifications"

"But Angular 2/Babel 6/Literally all of Javascript really does suck"

"Developers can't take criticism"

"Open source communities are bubbles"

"Every community is like this"

"All people are like this"

"Sorry, but..."

Didn't our mommas teach us that when you apologize, you _actually apologize_?
Even if you and I personally didn't do anything like this, this man here says
there's a problem. Let's work on the problem.

When you use an open source project, you pay for it with your contributions to
the project, whether those are code commits, bug reports, or just general
feedback - and maybe that feedback doesn't need to be sunshine and roses all
the time, but it should at least be concrete. Venting feels good, but it
doesn't help anyone, not even yourself [0][1]. The least we can do is to stop
normalizing knee-jerk, entitled, ad-hominem anger in our public fora. Because
_that 's_ what this article is asking for. No one is saying we need to go out
and fix all of human nature for a weekend project. We just have to stop
upvoting rudeness. Is that so controversial?

[0]
[https://www.ncbi.nlm.nih.gov/pubmed/23249241](https://www.ncbi.nlm.nih.gov/pubmed/23249241)
[1]
[http://psp.sagepub.com/content/28/6/724.abstract](http://psp.sagepub.com/content/28/6/724.abstract)

~~~
forgottenpass
_Let 's work on the problem._

Coo. But there's one of me, and 7 billion people that have - at least once -
been more of an asshole than warranted.

It's possible to simultaneously promote the change you want to see in the
world, and promote coping strategies for the transitional period.

The idea that we shouldn't need to deal with the status quo, but expect the
world to conform to our whims instantly is unreasonable.

------
throwayawnotime
I strongly suspect that the competitive environment in Javascript frameworks
and :s/tool/fool/ing is the main source of the negativity: Trolls have the
explicit agenda to demolish/demotivate what they're trolling in order to push
their own project/framework.

~~~
moron4hire
This is a really shitty thing to say, which you clearly understand.

The 90/9/1 comes in to play here:
[https://en.wikipedia.org/wiki/1%25_rule_(Internet_culture)](https://en.wikipedia.org/wiki/1%25_rule_\(Internet_culture\))

I have found that even sites like HN don't skew significantly far from this.
As users, we can't know who the 90% of people are who read this site and never
post. But there are definitely 9 times more people commenting than creating.

As an open source project maintainer myself, I have absolutely zero time to go
talk shit about my competitors, even if I had shit to say about them.

~~~
polotics
In my observation, one troll can and will show up under many different
identities, so there may be a 90/9/1 rule, but it can be gamed.

------
LyndsySimon
This sort of thing isn't unique to software. The same human behaviors that
first-line tech support has to deal with on a daily basis are driving this;
it's especially bad in F/OSS because it's often the case that the developers
and the supporters are the same people.

~~~
CaptSpify
Very true. Having worked at a helpdesk, many calls were about how
$new_software sucked. Most of that only got to the devs in a very generic
form. They definitly didn't look at every complaint that was logged

------
mwfunk
One reading of this is that people in open source JS community should be more
professional, but I think you could make similar complaints about electronic
communities in general. A blogger in 1999 writing about woodworking might have
had similar complaints about feedback from random readers on the Internet.

If you put anything out there on the Internet and encourage people to read
it/use it/whatever, you will inevitably be surprised and repulsed by how
nonconstructive and uninformed some of the feedback is. Web development might
be worse than other fields in this respect because there's just that many more
amateur, narcissistic, toxic teenagers (in spirit at least) who don't know
what they don't know diving into it, who are going to be somewhat more focused
on getting cheap upvotes on Reddit with angry rants than actually creating
things.

I don't know what the solution is. Some forums have higher SNRs than others,
and while I often enjoy Reddit, I have no expectation that the people posting
to programming subreddits are any better as a group than people who posted to
Slashdot in 1999. If you do anything and tell anyone about it, some bonehead
on Reddit is going to take issue with it and write an angry, uninformed,
thoughtless screed about how everything is terrible and it's all your fault.
You'll find some gems in places like Reddit as well, but it's just such a
random stew of people that you have to take it all with a huge grain of salt.

I agree with just about everything in the article, but given the number of
Reddit quotes used as examples, part of the author's problem is taking Reddit
too seriously or assuming that a given community on Reddit is a reflection of
a larger programming community, whereas often the opposite is true. Oftentimes
the people that post the most have the least to say, on Reddit (and the
Internet in general), as in life.

------
allendoerfer
I do not think that every blog post about a piece of software has to have
actionable advice for the maintainers. Sometimes you just want write a review
and tell other people that something sucks.

It is true, that this is a community where people are working for free and I
would personally try to consider that, when I say something online. It is
generally good advice to assume, that other people are intelligent, too, and
assume "there are valid reasons for this" before "they had other things to do"
before "they are stupid".

Doing something for free however does not free you from criticism. Imagine a
studio releasing a movie. Critics hate it, because it sucks. If the studio now
sets the price to zero, does that automatically mean all critics have to be
positive and friendly? No it does not. If something sucks, it sucks and you
are allowed to write about it.

~~~
dandelany
The thing is, a Hollywood movie is qualitatively different than a FOSS
library. In the former case, you are a passive consumer who paid money for a
product. In the latter, you are an active member of the JS community,
benefiting from the shared work of other developers _for free_ \- the only
thing they're asking for in payment is a bit of kindness, respect, civility
and ideally the occasional contribution. Plus, if there's something wrong with
the FOSS project, you have ultimate power to change it as you see fit.

IMHO reviewing FOSS projects as if they were shitty products you purchased is
extremely destructive to the FOSS community.

~~~
allendoerfer
> The thing is, a Hollywood movie is qualitatively different than a FOSS
> library. In the former case, you are a passive consumer who paid money for a
> product.

Not in my example. Not even talking about Hollywood. Could also be indie and
crowdsourced, just like FOSS can be sponsored by the biggest companies on the
planet.

> In the latter, you are an active member of the JS community, benefiting from
> the shared work of other developers for free - the only thing they're asking
> for in payment is a bit of kindness, respect, civility and ideally the
> occasional contribution.

Sure, and that would be the right thing to do. Still he mentions, that he has
stopped working on a project for being criticized for ASCII art. I do not know
the specific case and mostly I do not care enough, but it annoys me, too, when
developers try to be exceptionally funny and clever inside code - especially
when they fail. So I think you are allowed to criticize something like that,
if you want to.

> Plus, if there's something wrong with the FOSS project, you have ultimate
> power to change it as you see fit.

Does not apply to criticism about design decisions.

I think reviews (sometimes) have a value in itself for the reader and help to
create a working market of FOSS, where the best library gets the most users. I
get the developers point of view and can imagine how he feels, but playing
devils advocate here lets me conclude, that saying something sucks is okay.

------
usurpers
> It almost feels like you’re a politician at times.

Because that's what he is. He's a self-chosen software politician who admits
he loves his job. He's paid to travel the world and interact with his
constituents.

But he is upset that his audience sometimes writes a blog post, or worse,
nominally approves of adding an arbitrary number to a database associated with
a blog post. Somehow this is construed as a problem with the community.

It seems the community is functioning as intended, and grievances are being
hashed out. However, the author does not want to deal with the challenges of
listening to and interacting with the people he is being paid to interact
with.

~~~
thejameskyle
You assume I was being paid to work on Babel. I was not.

I worked on the UI team for Cloudflare, where we didn't even use Babel until
earlier this year shortly before I left. I worked on open source on the
weekend.

The vast majority of open source maintainers are not paid in anyway
whatsoever. Conferences pay me to fly places and stay in hotels because _they_
make a profit off of me.

Even now as I am paid to do open source. I don't think a single person on my
team would expect me to tolerate people yelling at me. I'm not a politician, I
can and do ignore plenty of people. Most of the time negative people arent
saying anything useful anyways.

~~~
usurpers
> You assume I was being paid to work on Babel.

I didn't assume that. This post isn't about Babel, it's about the "JavaScript
community", which you are being paid to work with.

> The vast majority of open source maintainers are not paid in anyway
> whatsoever.

I know. I'm one of them. I spend ~20 hours a week on open source on top of my
full-time job. I know how stressful it can be, but I'll never complain about
it because it's my choice to be involved. I'll definitely not be complaining
about it if that 20 hours was something I was being materially compensated
for.

> Conferences pay me to fly places and stay in hotels because they make a
> profit off of me.

Yes, this is how business works. Work is exchanged for tickets and
advertising. Part of the work is being a presentable and knowledgeable speaker
who can effectively engage and relate to the problems expressed by the
audience.

> I don't think a single person on my team would expect me to tolerate people
> yelling at me.

If there are people harassing you that is indeed a problem -- get the police
involved. That seems a completely separate issue from what's discussed in this
post though, which is a community that sometimes discusses technical arguments
in a way you consider abrasive.

~~~
thejameskyle
I wasn't saying that people don't have a right to be frustrated or angry. I
wasn't saying we shouldn't voice our criticisms as developers or that we
shouldn't disagree with one another.

The only argument I'm really trying to make in this article is that when
someone has stepped over a line into outraged attacks on tools and authors
that the community shouldn't reward them for that.

Apparently this is too much to ask because so far today I've been called:

\- a special snowflake

\- autistic

\- whiney

\- thin-skinned

\- pathetic

\- weak

And I only published this like 2 hours ago and I have hundreds of
notifications to go through still. The next few days I'm probably going to get
a hell of a lot worse. Still waiting for my first "faggot" which always
inevitably happens.

I have some pretty thick skin. I was raised in an abusive environment and I
made my own way in the world at 16.

I'm not bothered by one person saying I'm an idiot.

What gets to you is a few thousands people agreeing.

~~~
sosuke
I looked back at your story a couple of times but couldn't figure out how the
outraged attacks are being rewarded. I do feel like you might be on to
something in how critical comments are often the most discussed. Think about
how the single like "thank you" or "thanks for that" comments are hidden as
being empty of thought.

I don't have any solutions but have you seen this CGP Grey video called "This
video will make you angry"
[https://www.youtube.com/watch?v=rE3j_RHkqJc](https://www.youtube.com/watch?v=rE3j_RHkqJc)
which says that outraged ideas are the quickest to spread.

------
bryanrasmussen
I thought the purpose of the Angular 2 is awful article was not to get the
Angular 2 people to improve it but to make an argument for why people should
not use it.

Just as in art you can say that there are technologies that you believe are
not to your taste and ones that you believe are bad (and there can also be
technologies that aside from these categories are also morally bad - AMP).
Angular seems to me to be one of those technologies people often think are
bad. In the interest of avoiding pointless argumentation (god I'm getting
old!) I guess I won't put my opinion here.

------
ceedan
Sounds like OSS projects need a better way to moderate issues. If github had a
setting to force issues to go through a moderator feedback/approval cycle
before becoming public, it could reduce this behavior. Wouldn't help for
Twitter and whatnot, but at least it would help somewhere.

------
rpeden
As others have pointed out, people being mean, angry complainers when
something doesn't work the way they want it to isn't unique to the programming
or open source communities.

I think some of us are bothered by it because we tend to to think of ourselves
as logical and rational, and we expect others like us to behave in the same
way.

From observing things over the past decade, it appears to me that there are
plenty of developers who are willing to fly off the handle and write whiny
rants about things that irritate them.

Maybe part of it is that the posts that sound like they're written by a
petulant child get the most attention. I often find myself disagreeing with
points in them, but have never felt the need to spout insults about libraries
and frameworks or their creators.

Up 'til now, I've been content to reply to these rants on HN and Reddit, and
try to inject a bit of reason and calm into the discussion. I think it's time
to be more courageous.

I'd like to start writing rebuttal blog posts in which I tell the authors they
sound like whiny ingrates and demonstrate how they could have written their
criticism constructively. I'm just not sure whether trying be be reasonable
will actually help the community, or will just get me lots of nasty replies
and e-mails.

------
qwertyuiop924
I don't think I can say much about the article's main point that hasn't
already been said. But I do have a question:

Why the flying blue !@#$ would _anybody_ think that Babel 6's Configuration
over Convention decision was the _wrong_ way to go? It was absolutely the
right thing to do. It made Babel a far more uniform and simple piece of
software, and actually made it easier to use.

 _Why?_

~~~
bshimmin
Most people use Babel for transforming ES6 into ES5. Before Babel 6, Babel did
that out of the box with no configuration required. With Babel 6, it basically
stopped doing anything out of the box, including the main thing it was famous
for doing. While it is admittedly not a vast amount of effort to make it do
precisely what it did before, I'm sure you can at least sympathise with people
who found it strange that you have to include a "preset" to make it do the
main thing that you expected it to do.

------
jmcdiesel
As with seemingly ever problem over this last few years, this just comes back
to the same basic problem. Entitlement.

People feel entitled that your library works the way THEY want it to work.
They are entitled to feeling that changes you make should agree with THEIR
project workflow. They feel entitled to complain when its not exactly what
they want.

Entitlement is going to be this period in time's label...

------
igotsideas
Some people tend to forget that a lot of time goes into all these tools and
they are free to use. Some of these engineers spend time fixing OSS problems
instead of hanging out with their kids. Good read..

------
jondubois
I dislike all JavaScript transpilers. I still cannot get my head around how
CoffeeScript ever got so popular. The complexity and friction that transpilers
add is not worth the tiny benefits that they offer. I've worked on many
projects where I had to wait for like 20 seconds for the code to compile each
time I made a change to it.

From my point of view, it sounds like the author of this article is merely
feeling the reality catching up to the hype.

Transpilers like CoffeeScript and Babel should never have become popular to
begin with. Something unnatural happened in the evolution of those projects
which allowed them to capture a lot of attention very quickly; and much of the
initial adoption was driven by hype and network effects instead of real needs.

~~~
rudolf0
Just to provide a contrasting point of view: CoffeeScript is the only reason I
ever wrote, and ever write, JavaScript. Period. Transpilers do add a layer of
complexity, but all of the syntax sugar advantages make it more than worth it
to me.

I would not ever write JavaScript if CoffeeScript or similar languages did not
exist. Before it existed, I never touched the language. I now use CoffeeScript
daily and have never been happier. A watchdog script automatically transpiles
the code upon updates, and everything is completely seamless for me.

~~~
jondubois
The real problem that CoffeeScript solves is developer stubbornness.

Some developers decided a long time ago that JavaScript is terrible and so
CoffeeScript gave them a way to program in JavaScript without changing their
minds about how terrible JavaScript is.

The reality is that it would have been easier if developers weren't so
stubborn to begin with.

~~~
rudolf0
It would have been easier if JavaScript weren't so terrible to begin with.

------
datashovel
I think the context everyone needs to start taking with internet comments /
blogs / etc. is that "everyone can be part of any open community". The other
important thing to take is "everyone can voice their opinion". This, if the
majority of us really dig deep, is what we wanted and why we invested so much
time / energy into the web.

I would say that only in recent years has it felt like the most ignorant are
really starting to ratchet up their rhetoric. I still see it as a truly
powerful thing even when it can / is used destructively.

Also, given the ad-driven world of online, my guess is a large number of
"relatively intelligent" rants we see online ramp up their tone only to drive
more traffic. It's sad state of affairs, but true. My belief is the internet
is still very much a meritocracy. As long as good work continues, it will
continue to get well-deserved attention and praise. The thing that is changing
and the way I think we (oss contributors in general) need to adapt is by
making sure we don't let the noise rattle us.

EDIT: In terms of how the particular issues arose (backlash) for Babel 6, I
would say the only thing you'd probably want to do is assess the project's
methodology for how word gets out and how easy it is for people in the
community to participate in discussions of changes that will affect users.
Perhaps making it explicit on the project websites which channels are
"official" channels where the project's work occurs.

In the end decisions / progress needs to be made. If everything is done as
"above board" as possible given resource constraints of the project, don't
ever let the backlash make you feel so guilty that it might change your mind
about whether to contribute. Those who are the loudest are probably the least
involved and sadly the most dispensable. Of course you don't want to think in
those terms, but I think it's a lot worse to try too hard to appease loud /
ignorant / uninvolved community members. That is probably the main thing that
will lead the core team to want to disband the project altogether.

------
vorpalhex
It seems there are two things going on here.

1\. Upset that people are now reacting negatively to this change as opposed to
voicing criticism earlier

2\. Being upset that criticism exists

(2) is the sort of problem I can't help with except to say maybe grow a
thicker skin or be a bit more aware of what it was you signed up for, but in
regards to (1) -

It's important to note that the people heavily invested in your project
(enough to follow every new issue on Github and respond to them and have
opinions) will be very different from your mainstream users. There is no
shortage of people who heavily use a project and yet probably don't follow
them in any way. So it's important to note that using that source of feedback
likely subjects us to bias.

~~~
codezero
The argument that people should grow thicker skin is part of the problem. Why
do we expect people to grow thicker skin rather than expecting them to be more
courteous/civil?

Edit: also the argument to grow thicker skin is seemingly ignorant of scale.
Sure a few criticisms should be shrugged off but should thousands, which are
disparate, incoherent and likely personally insulting, be part of the thick
skin department? Where is the line drawn, and who draws it?

~~~
CaptSpify
Because thats how people are. _Especially_ the general public. I absolutely
think people should be nicer, but how do you encourage/enforce that? We've
been trying for a long time without good results. I'm not saying that we can't
fix it, but I haven't seen many attempts succeed.

------
tnones
I understand the author's frustrations. Open source is lovely when it works,
and communities can be fun when you're part of them. But I understand the
other side too. Most people don't care, and they shouldn't have to care, yet
they are told to regardless.

The flipside to all this griping about entitlement is that most open source
ecosystems are set up as an explicit groupthink and infrastructure to which
you must defer. You can't just grab something and keep playing by yourself,
no, you must keep moving in lockstep with everyone else, or things will break.
That's why people get frustrated and angry, and that's why they barge into
issue queues feeling miffed. They gave up too much control to too big an
entity, and it bit them in the ass. Angular 1 should be a big lesson here:
people abandoned the entire framework in droves simply because the _promise_
of future updates was taken away. The beautiful carriage turned back into the
pumpkin it always was, and now the rot was starting to set in.

Even something like node.js with its fractally versioned npm packages has this
problem. Drop-in compatibility is only true as long as you're in the sweet
spot of doing what most other people do, on the version most widely installed.
Not too bleeding edge that you can't expect StackOverflow to have gotten there
before you, but not too far behind that you lose compatibility with the
important dependencies.

The author concludes "If we focus on solutions, focus on helping others, focus
on sharing ideas, we’ll be in a better place." I disagree, because too much
sharing is what got us into this mess. The answer is more self-sufficiency,
with enough affordances for going at it by yourself if you want to. Alas, that
doesn't jibe with the latest fad of inclusiveness, so I'm afraid the same
people griping about civility are the ones doomed to recruit more ineffective
members into their congregation.

------
z3t4
The best way is to get a bunch of people to answer messages for you, and
filter out personal insults. Also you do not need to read the news, it's
possible to live under a rock and still write the best software. If you want
to talk to other like minded, conferences are nice, and also IRC, there's
always nice guys lurking there and if you write something interesting they
will wake up, just be patient.

Then there are community management, everything you say or write can be used
against you, and there are trolls trying to make you look bad. The community
can be very powerful if managed though, thousands of people can achieve a lot
together.

When you make something successful, people will love you, and we all want
attention, so it will be hard not to become a public figure, but you're better
off not to, because there will also be haters and if you make a bad move,
those fans can easily turn into an angry mob.

------
dsego
When you try to sell something as the next best thing since sliced bread,
expect some criticism if it doesn't deliver.

------
andrewstuart
I wrote the mentioned “[Babel 6 is] a lesson in how not to design software”.

Maybe I shouldn't have written it at all. It's never my intent to hurt or
insult anyone. Not by way of excuse, but by way of explanation all I can say
is that Babel 6 is at the heart of JavaScript, and my experience of using it
was days of crushing, mind bending pain because I had to configure everything
- the point of the blog paost being that conventional wisdom is to make a set
of rational configuration choices for your user, whilst Babel goes the
OPPOSITE way - it does NOTHING by default.

Perhaps if a person is unhappy with the outcome of using some open source
software then the best thing to do is just turn away and silently stop using
it.

Hard to do though when that software has become central to the ecosystem.

I hope I was criticising the software design decisions and not the authors.

------
ggregoire
The people who appreciate your projects and would love to thank you everyday
for your amazing work are the silent majority.

See Font Awesome 5. When they announced the KickStarter on HN, a minority
criticized the existing library (like how the lib is shitty) or their future
plans (like how having a pro version is wrong). But at the end, they raised
almost $1 million. That shows how the biggest part of the community is really
thankful.

If FA5 can raise $1M, I can't even imagine how much could raise Babel, Webpack
or Homebrew. You made our lives so much easier.

\---

Also, can't recommend enough this book:

The Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a
Good Life - [https://www.amazon.com/Subtle-Art-Not-Giving-
Counterintuitiv...](https://www.amazon.com/Subtle-Art-Not-Giving-
Counterintuitive/dp/0062457713)

------
mschuster91
The problem with the JS learning curve is the HUGE amount of StackOverflow and
blog posts that are insanely outdated, with no way for the casual reader to
check if the question or the answers are actually usable on a modern version.

I believe that this, combined with complex, incomplete or outright missing
documentation (hello Webpack, though the situation has improved since a couple
of months) is something that holds the JS community back very hard - also
because people complain all the time to framework authors "the example I c&p d
from stackoverflow doesn't work" and answering these complaints takes nerve
and time.

The PHP community suffers from the same fate, btw - remember mysql_*? People
still find it in the top 10 Google results for some questions.

The only environments that have managed to resist this problem are Win32 and
the userspace part of the Linux Kernel. In a lot of cases one is able to even
open a VC6 project in a modern Visual Studio, have it converted and building -
or at least just having to mess with the VC build process, but thanks to a
hell of #ifdef's, the Win32 code still builds - and runs! For what it's worth,
I can run Windows 95-era EarthSiege 2 on a 64-bit processor and the only
things broken are the joystick input (by disassembly I believe the responsible
code suffers from a bad version check on a struct) and some timer that binds a
specific movement to the framerate and naturally overspeeds as a modern system
can easily hit 100 FPS.

Same holds true for the Linux kernel, it's amazing that a statically compiled
game like UT2004 still runs on a modern day Linux system.

In contrast, JavaScript - "npm install <whatever>", as many tutorials
describe, is likely to already give an incompatible (with the instructions)
package when the book finally gets printed. I have the feeling that like with
libraries, major versions should always be backwards-compatible for their
subversions, and have different NAMES for their major versions, e.g. "npm
install angularjs1" vs "npm install angularjs2".

------
bjornlouser
"Some of the best [experiences] include being invited to conferences around
the world to speak getting to travel to places I never thought I would and
making friends from around the world."

Are the motivations of maintainers aligned with the developers using their
software?

------
kazinator
> _Hacker News often rewards negativity._

Hacker News has a very good mechanism for combating negativity. However, the
moderation mechanisms of Hacker News cannot suppress the mass hatred of
something.

When we see, on HN, a pattern of seething negativity against something leaking
through the fine moderation system, maybe that something has some property
which induces negativity. Be it completely unfair, or be it rationally
justified, there it is.

There is a way not to be confronted with anything negative, while staying
online: join one of those social networks whose job is to feed you ads,
surrounded only by content that you like, based on your liking history.

------
Kequc
This isn't to say people shouldn't ideally be nice to each other whenever
possible. I'm so tired of hearing about how someone was slighted on the
internet. Whatever it is you put out there will potentially be seen by up to 6
billion people. So "every day" you log in and see "yet another" negative
comment? Grow up! There's no nice way to say that.

There's going to be negative comments on the internet please please stop
complaining about it. I've been hearing people complain about negative
comments on the internet for years it is not going to stop. Find another way
of dealing with it.

~~~
midasz
>I'm so tired of hearing about how someone was slighted on the internet.

Deal with it?

------
codezero
Does anyone have any suggestions on alternative communities that are more
positive?

Reddit and HN are easy because they are pretty consolidated, my best guess is
that these other communities are small and hard to find.

------
rygine
I usually don't comment about these type of posts, but I felt I had to speak
out here when the author of this article has been an offender of the things
he's trying to promote. Perhaps he has just "seen the light," but I have my
reservations.

Specifically, these lines got to me:

>If we focus on solutions, focus on helping others, focus on sharing ideas,
we’ll be in a better place. We’re all part of a broader community and we all
have an impact on it. We can either have a positive impact or a negative one.
It’s entirely up to us.

> This is the reality the community faces. We can either work to fix it or we
> can continue digging a deeper hole for ourselves.

At my company, we were using Lerna [1], a library to help manage mono repos.
It wasn't perfect, but it worked. So I thought I'd contribute. I spent a good
deal of time replying to issues, fixing bugs, and working on new features.

This was at a time when the author was mostly absent. Without the amazing help
of gigabo [2] and hzoo [3], the project would have grinded to a halt. As new
users rushed in to use this relatively new tool, there were many new issues
and feature requests.

When the author did make his presence known, he was not very helpful [4] [5].
These are just the examples that stood out to me as a contributor. Most people
understand that 1 person can't be expected to maintain a big project like
this, especially when they are busy at Facebook bootcamp. That's why it had 2
additional members to help. Unfortunately, as a result of [5] above, the
author decided he no longer wanted [2]'s help and removed him from the
project. He removed a huge contributor because he disagreed with him and
failed to openly discuss the issue. Ironic. I stopped contributing
immediately. As a result, Asini [6] was born.

The thing that really pisses me off about this post from the author is that
he's promoting open communication, sharing, helping others, etc... when it's
the complete opposite of my experience with him. Maybe he just had a bad day
on those days, maybe it was something else. I don't know him personally, I can
only assume things based my interactions. Regardless, this was some extremely
poor handling of an open source project.

It looks like he's active on the project again, but it doesn't look like much
has changed. [7] [8] [9]

Mr. Kyle, if you're reading this, I really hope you'll follow your own advice.
If I have misunderstood your actions in the past, I'm open to being wrong.

[1] [https://github.com/lerna/lerna](https://github.com/lerna/lerna) [2]
[https://github.com/gigabo](https://github.com/gigabo) [3]
[https://github.com/hzoo](https://github.com/hzoo) [4]
[https://github.com/lerna/lerna/pull/255#issuecomment-2289545...](https://github.com/lerna/lerna/pull/255#issuecomment-228954543)
[5]
[https://github.com/lerna/lerna/issues/334#issuecomment-24639...](https://github.com/lerna/lerna/issues/334#issuecomment-246393716)
[6] [https://github.com/asini/asini](https://github.com/asini/asini) [7]
[https://github.com/lerna/lerna/pull/255#issuecomment-2523322...](https://github.com/lerna/lerna/pull/255#issuecomment-252332281)
[8]
[https://github.com/lerna/lerna/pull/386#issuecomment-2640725...](https://github.com/lerna/lerna/pull/386#issuecomment-264072507)
[9]
[https://github.com/lerna/lerna/issues/408](https://github.com/lerna/lerna/issues/408)

~~~
thejameskyle
I got to work on Lerna for about two months while working at Cloudflare in
order to ship cf-ui. Otherwise it was in the middle of a period where I mostly
backed out of doing open source because of frustration with the community from
early this year. So if Cloudflare hadn't done that I probably never would have
gotten involved.

I'm sorry I was often short-breathed when responding. I'm sorry I shut people
down more than a few times. From my perspective Lerna was feature complete
until Yarn was launched, and people were only ever making feature requests so
I didn't see a big deal.

At one point I was frustrated and Bo made it seem like he was going to abuse
his power as a contributor and I got freaked out and removed him. He only got
more and more vocal from there and I just pushed him out entirely.

Since then I've started a new job, a new relationship, I've been exhausting
myself writing new talks. I've had family problems, work problems, fucking
country problems... a family member who has been having suicidal thoughts,
family who have practically disowned me for being gay and refusing to take
their shit.

To be honest, I've barely been getting by in life before we even start talking
about open source. I have to take care of that first.

I'm sorry.

~~~
gigabo
Hi James,

I'm really sorry to hear about the difficult time you've been having. I can
see how that would make an already thankless job like maintaining an open
source project even more frustrating.

During my time as a Lerna contributor I was careful NOT to abuse my power. The
few times I merged PRs I checked with Henry first. I pinged you at the
beginning, too, but stopped eventually when I didn't hear from you. Mostly
what I did, though, was triage issues and work with other contributors to get
PRs into shape. I spent a lot of time over the summer working on Lerna, and
only a small part of that was the code I wrote myself.

Then, suddenly, you started deleting my comments and locking my issues. You
removed me from the organization without any discussion. That seemed to me an
abuse of YOUR power. It hurt.

Please re-read the first comment of mine that you deleted. It wasn't meant to
be aggressive. It was a plea.

\---

My inspiration here comes primarily from two sources:

1\. Using Lerna every day and thinking about how it could be improved to make
my life easier.

2\. Listening to feedback from _other_ Lerna users about how it could be
improved to make _their_ lives easier.

You're one of the original core team, and I don't want to alienate you. Your
rewrite of Lerna put in place a foundation that has been a pleasure to work
with. But lately maintenance and improvement has continued in your absence
thanks to contributions from Lerna's fledgling user community. Do you plan to
reassume this responsibility?

\---

That was here [1], but you deleted it and then locked the issue. I hope as you
read it now you can see why it was surprising and hurtful that this was your
response.

[1]
[https://github.com/lerna/lerna/issues/334](https://github.com/lerna/lerna/issues/334)

------
jondubois
I'm the creator of a popular open source project (but not Babel-popular). I
don't have a problem with people complaining about my work; if anything, I
wish they would complain more - That way I would have a better idea about
which parts need to be improved!

I think that the author has no grounds to complain here; he's one of the lucky
ones. I wish I was in his shoes and have people yell at me in desperation so
that I could fix their problems (whilst travelling around the world). That
sounds like a dream to me.

------
halis
This isn't unique to open source software development. Anytime you're a public
figure or a public company or otherwise working in some highly visible
capacity, there are going to be haters in the building.

It doesn't matter what you do, you could say that you're against the
strangulation and drowning of kittens and there would be someone(s) out there
shouting to the sky that you should be shot in the head for saying so.

Fuck em! Ignore it. Move on.

------
STRiDEX
I remember that angular 2 thread. Half of the problems were the breaking
changes between release candidates. I was one of those early adopters, pushing
my code along between releases. It was bad, but nothing I didn't expect. They
talked about the changes and explained the motives clearly.

I think the problem is people want to be bleeding edge without joining the
community.

Edit: question for James. What did you build with angular 2? Is it public?

~~~
thejameskyle
> What did you build with angular 2? Is it public?

Heh, I build the same thing every time because I am not creative. Here's the
Marionette version: [http://marionettewires.com/](http://marionettewires.com/)

I could put it out there. The problem is that people assume when I share
something that I am trying to tell them how things should be, like I'm some
software design #thoughtleader genius. When really I'm just blindly trying to
figure out what the hell I'm doing.

------
yegortimoshenko
> When we launched Babel 6, we made an API change that we had planned for
> awhile. We moved from having an implicit (“works out of the box”) behavior
> to an explicit (“will work for everyone”) behavior.

Just like Rich Hickey said in his last talk (see
[https://news.ycombinator.com/item?id=13085952](https://news.ycombinator.com/item?id=13085952)),
breaking changes are broken. For greater good or not, it's no surprise people
complain when you break their code/workflow.

> I want to talk to you about an article that was written the other day titled
> “Angular 2 is terrible”. For starters, that title alone is an attack on the
> maintainers. Surely the author wants a set of problems addressed. But why
> should the maintainers want to even click on that link, let alone try to
> address the problems?

I too think that Angular 2 is terrible. It is not an attack on the
maintainers, it is just a piece of (IMO) bad technology with maintainers
feeling attached to it.

It is a very crucial skill in life to be able to withstand critique and take
it to your advantage. There is a lot of usually unnoticed utility hidden in
critique, waiting for someone to reap its benefits.

~~~
thejameskyle
People keep assuming I have something against sharing criticism or
frustration. I never said that. I explicitly said that's not what I'm trying
to say.

I'm saying that when someone does it in a way that is in pure unadulterated
anger that the community should not reward them for it. It's unhealthy for
everyone.

~~~
yegortimoshenko
I don't think you understand. The critique itself, whether constructive or
not, is something to learn from.

Just like breaking changes in Babel 6. There is a lesson waiting to be learnt,
namely, don't make breaking changes to existing software.

As a matter of fact, I honestly don't understand why you take it so
personally. Sometimes I do stupid things and people call me an idiot, and it's
helpful to know that. Sometimes it gives me a perspective I haven't thought
of.

Look at how Theo de Raadt and Linus Torvalds manage their projects. It is kind
of the same.

~~~
Klathmon
If I can ask, what's your alternative to breaking changes?

Most of the time when I see a large library make breaking changes, it's to
solve a problem which can't realistically be "fixed" without breaking changes.

And even if they can provide a "shim" to allow people to use the old way of
doing things, people see that the same as they see maintaining an old release.
That you need to upgrade to the latest version or you'll be left behind.

I'm not trying to put words in your mouth, but it seems like the only options
left are to "never improve" or "get it right the first time". And obviously
the latter isn't possible pretty much at all.

~~~
yegortimoshenko
I'd argue that most breaking changes are not about fixing problems. They are
about API consistency and taste, like Babel 6 mentioned above.

If problem is a bug that people might rely upon, I don't mind fixing it. If
problem is _fundamental_ design-wise, however, the right way is to create a
new library.

There are a lot of designs that never break anything (or at least try hard not
to): Linux, macOS, Erlang, Java, Clojure, x86 instruction set, life on earth,
and they all improve over time. And they obviously didn't get everything right
the first time.

------
erikpukinskis
This reminds me of a powerful skill we could probably use a bit more of in
this day and age:

Recognize when you're just the flashpoint for someone's anger, not the cause
of it, and don't take it personally.

Abuse shouldn't be tolerated of course. But sometimes you're just the straw
that broke the camel's back. And in those moments, if you can let yourself off
the hook, and realize that there is a bigger issue going on, you can often
redirect the conversation toward that bigger issue.

Maybe if OP spent less time defending himself, less time taking the complaints
personally, and more time just commiserating with people about the changes in
the JavaScript community and how we should deal with them... maybe those
interactions would've gone better and he'd be less burnt out.

I realize this is victim blaming, from the perspective of someone who was just
bullied. So, please don't take this as a critique of OP. It's just a path I am
trying to keep in mind.

------
_asciiker_
hey now ...

"I’ve always been advised to avoid these “sub-communities” like /r/javascript
and Hacker News. Maintainers say they are filled with assholes who don’t know
what they are talking about, angry idiots shouting at everything and everyone,
cesspools, giant piles of trash burning in the wind."

I find that HN has one of the most sober comment sections I could ever wish
for, it's certainly better than Reddit. I mostly come here for the comments.

~~~
mrec
You can't really generalize about Reddit comment quality; it depends entirely
on what you're looking at. Quality is strongly inversely correlated with sub
size, so all the default subs are pretty bad. But there are notable exceptions
to that correlation, like the consistently awe-inspiring /r/askhistorians

------
tomkadwill
Great post. Open source maintainers clearly have some responsibility but we
need to remember that they contribute their free time to make users lives
easier

------
wattt
Rather than acknowledge some of the criticisms are true the author complains
that complainers are the problem. Can't see the forest through the trees.

------
shanemhansen
I think there's a fundamental mistake the author is making. Sometimes
complaints about frameworks are not directed at framework authors, but at
users. Sometimes people need to be warned away from bad software.

Specifically the author references a NG2 article that is trying to warn
developers, not bash maintainers.
[https://meebleforp.com/blog/36/angular-2-is-
terrible](https://meebleforp.com/blog/36/angular-2-is-terrible)

------
marknadal
I thought I agreed but then I read this guy's pinned tweet thread, and he is
being very demeaning of other people "Shut up David, no one likes you"
[https://twitter.com/thejameskyle/status/788799662438227969](https://twitter.com/thejameskyle/status/788799662438227969)
(I don't care if he's being sarcastic or teasing, this isn't the attitude that
makes people feel uplifted).

------
adrianlmm
The "Angular 2 is Terrible" article was not a clik-bait and it wasn't
exagerating, Angular 2 is indeed, terrible.

------
edblarney
Chin Up.

------
xamuel
Apologies to the author, but rants serve a purpose. They comfort those of us
forced to use a framework we don't like. If they demotivate you, that's your
problem, not the world's. Move your site to Facebook if you want nothing but
likes.

------
zeveb
Has the author considered that maybe, just maybe, negativity can be justified?
Sometimes when one sees people wasting yet another man-decade in yet another
attempt to make JavaScript not fundamentally broken the only thing that can
possibly work is to say, 'your project is _stupid_ , because you're trying to
make a silk purse out of a sow's ear.' If reasoning doesn't work, if polite
criticism doesn't work, then _maybe_ being direct will work.

Or maybe not. I generally try to reason through this kind of thing. But after
awhile one realises that if every programmer has to learn why JavaScript and
single page apps are both fundamentally and accidentally broken, then
thousands of years of cumulative programmer effort will be completely wasted.
Maybe it'd be faster just to say, 'that's stupid: do it this way' and short-
circuit the whole process. It'd be even better to say, 'that's ill-advised,
here's why, and here's how to do it better.' But if the other part won't
listen to the long explanation and doesn't wish to learn — then it seems to me
that the last-ditch mechanism is rudeness.

~~~
qwertyuiop924
...But that's not even what he's talking about here. He's talking about people
continually insulting him and his project over the internet, without even
discussing the grievances they may have, legitimate though they may be.

Also, JS isn't as fundamentally broken as you think. C is far more
fundamentally broken than JS, and you like C, right? I mean, I kinda like C,
too. But it's broken.

~~~
zeveb
> Also, JS isn't as fundamentally broken as you think. C is far more
> fundamentally broken than JS, and you like C, right?

Heck no! I think that the existence of C has set the fields of information
technology, operating systems and computer science back by at least 50 years
(yes, longer than C has existed: it's that bad).

I don't hate K&R or any of the other folks involved with C and its
descendants; I don't think that they were actively malicious. But I think that
their work has inadvertently made the world worse than it could have been.

~~~
qwertyuiop924
Well, at least your POV is consistant. Which is more than I can say for many
here.

I maintain that JS is an acceptable language despite its flaws, and that the
best way to write JS is to just buck up and learn about them, rather than
trying to paper them over.

