

Farewell CoffeeScript - staltz
https://github.com/staltz/rxmarbles/commit/57e37f176e0e005abd2c4fa0253bbd8f57fe1bd9

======
mmahemoff
This is like a lot of "religious" language comparisons. It's written by
someone who is intimately familiar with one and (appears to be) fleetingly
familiar with the other.

The author makes some odd assumptions about CoffeeScript's intentions, ie
language reduction and protecting against "evil code". All of this ignores the
real main benefit, which is cleaner syntax, which means less finger typing and
easier comprehension of a large and complex code base.

There was a time when JavaScript was the only real choice for browser-based
web development. There were compilation tools like GWT, but they were
heavyweight and generated the JavaScript equivalent of binary, completely
detached from the source code. Now that the JavaScript++ languages are here
(CoffeeScript, TypeScript) and well-supported in the browser thanks to source
maps, I find it hard to imagine why people continue using raw JavaScript with
all the bloated keywords, curly braces, etc (apart from legacy code bases).
Usually it's because they haven't used anything else, and are content to focus
on the negative of Coffee etc and stick to what they already know.

~~~
funkybro
I'm interested to know what value TS/CS devs get from their code translating
to "legible" JS?

~~~
chaz72
I used TypeScript for a project earlier this year. As a C++/C# expert and a
JavaScript noob, I found the clarity, the readability of my code to be far
superior with TypeScript, well worth the extra tooling.

Then I found that after working that way for a number of months I no longer
needed it. I picked up enough JavaScript along the way that I could I drop the
training wheels and I am not looking back.

------
LBarret
So this is a kind of teenage hubris thing ? In which other field this would be
normal ? I play the devil's advocate there, but please bear with me : IMHO,
this attitude is among the causes of the high failure rates of many projects
(personnal or pro).

The constraints are minor, the gains of coffeescript quite clear. There is no
important gains in sight that justify moving to js. So why changing ?

Changing for the sake of change, is silly and something all of us do. A
successful project needs as much technical stability as feature stability.

~~~
weego
_the gains of coffeescript quite clear_

As someone who has been writing JavaScript for 15 years and has never felt
like writing it is a struggle I would ask... are they?

I don't know what it solves. Writing a language designed to be written by hand
in another language and then transpiled to the first language you have to know
in the first place to be any good at it has always seemed like a horrible non-
solution. You don't know what you've actually written at that point.

~~~
mmatants
I feel a lot of folks are not mentioning a huge thing CoffeeScript is valuable
for - its list comprehensions and proper for-each. JS has them too as part of
ES5 spec, but CS still is an elegant solution. It creates a whole new way to
speak code, like in Ruby, Python and others.

Syntax, variable niceties are great too, of course, but do not define CS
alone.

------
tinco
Ungrateful 4 year old, he'll back before supper. If Ruby raised you well, I
know python is a bit of a sloppy father though its heart is in the right place
and he brings home the bacon, you'll know it's not just about the 5% code
reduction. It's about abstracting away the inconsistencies of the language,
revealing its inner elegance and power. CoffeeScript is not a cloak to hide
JavaScript, it's the suit that makes you see and respect its power.

------
jeswin
I recently migrated a fairly large CoffeeScript project to JS, after using CS
for more than three years. ES6 and ES7 addresses many of the pain points of JS
right now. So my sugggestion would be to use an ES6/ES7 transpiler instead of
CoffeeScript.

\- JS produced by the CS compiler isn't that great, to be honest.

\- Plain JS is easier to debug than CS, even though you have source maps.

\- Source map chains don't always work. So using CoffeeScript together with
another tool which produces its own source maps could be a problem.

\- Build time could go down without CS

\- Way more devs understand JS than CS

\- I might have considered sticking with CoffeeScript if it had plans to
evolve, perhaps add more functional features. But jashkenas considers
CoffeeScript mostly done. As michaelficarra mentions in
[https://github.com/jashkenas/coffeescript/issues/3073](https://github.com/jashkenas/coffeescript/issues/3073),
"CoffeeScript needs to evolve or die"

\- When ES6 gets implemented, just get rid of the ES6/ES7 transpiler and you
have plain JS

I haven't read the article, but if you ask me CoffeeScript is dying.

------
anko
I wish there was a bit more to the explanation, like examples of the naming
issues listed.

I've found that coffeescript prevents whole classes of bugs, and makes lots of
javascript warts nicer to live with.

For example, you don't seem to run into scope issues, and it's a lot easier to
bind this to what you expect.

5% more code (if it really amounts to that) is still more code, too! No code
is like no code.

~~~
bhaak
Look at the commit beneath the commit message.

From the README: "The architecture is a simple MVC heavily dependent on RxJS"
and that's exactly how it looks, just linking different components together
without hardly any glue code.

If all his code looks like this, he certainly doesn't need it to be in
CoffeeScript.

------
mdavidn
Without CoffeeScript, automated JavaScript linters are your friend. Run them
in your editor, test suites, and asset pipelines. They'll catch those pesky
"var" and "===" typos.

[http://www.jshint.com/docs/](http://www.jshint.com/docs/)

~~~
swartkrans
> They'll catch those pesky "var" ... typos.

So will "use strict";

[https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Refe...](https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Reference/Strict_mode)

~~~
reidrac
But what if you're targeting the browser? Is the strict mode supported?

~~~
davedx
We just transitioned our code base to "use strict". If you use it in
combination with a module system it works painlessly, and indeed prevents some
classes of bugs.

------
resca79
"Also, in the end of the day, your generated JavaScript is just about 5% more
verbose than actual CoffeeScript code, so I don't see real benefit."

I disagree with this sentence.

Anyone use coffeescript only to reduce the code verbosity, maybe wrong.

It's a simple evolution of thejavascript language that currently has an old
syntax. Do not confuse old syntax with popularity and power of the language
itself.

Many programmers have figured out that readability and clarity code are a good
stuff, especially looking forward if the project will become big and much
complex.

It's why Swift or Rust were created, not why their code is less verbose of
Objective-c or C, but because they have a clear syntax, and it helps
programmers in their productivity.

------
dasil003
JavaScript is a wonderful place to sow your wild oats and create your own
object-orientation schemes, its prototypal inheritance is wonderfully powerful
and fun to play with.

However when you get to building non-trivial systems with javascript you need
to pick a style and stick with it. In that regard you can do much worse than
CoffeeScript.

------
galfarragem
If I could choose I would choose Ruby over Javascript ANY DAY (I am not saying
that is better, just that sintax is easier to pick for an hobbyist as me).

But I can't. JS is everywhere and I don't have time to learn several
programming languages.

CoffeeScript was a way to make JS more enjoyable to me. You can say that
CoffeeScript is still another language to learn but once that is related to
JS, you learn both simultaneously, killing two birds with one stone.

~~~
isxek
Ever heard of Opal ([http://opalrb.org/](http://opalrb.org/))?

------
cheald
I'm not quite sure what the point of this is. A scan of the diff doesn't
reveal anything particularly interesting being done in Javascript that
Coffeescript would get in the way of. It's fine to argue that Coffeescript
gets in your way and prevents you from doing things that you couldn't do
otherwise, but at least demonstrate examples to that effect.

Even more perplexingly, there are methods like `merge` in examples.coffee/js
which, in the Javascript version, are effectively compiled Coffeescript, and
which are less concise than they should be; why does the Javascript version
call `Array.prototype.slice.call(arguments)` when arguments is never treated
as an array outside of length and subscripting, both of which the arguments
object already supports? Coffeescript does it specifically so that using
arguments as an array is transparent to the user. Why is it necessary in the
Javascript version, when the only effect is the creation of an additional
object?

It's somewhat silly to argue for Javascript on the basis of it offering finer
control over the code, and then not using that control. If you just don't like
Coffeescript, fine, but let that be your argument.

------
pmontra
Despite their share of problems (the author explained what's wrong with
CoffeScript in his opinion), languages compiled to JS will keep flourishing
unless some future ESx will turn it into a more conventional language. Even in
that case, being the native language of the "internet virtual machine", people
wanting to use a language-X-look-alike for the front end will keep designing
their transpilers.

In my case I never considered CoffeScript because of the indentation/semantic
spaces thing. I had to work with those languages sometimes and the troubles I
had when moving blocks of code around and copy/pasting examples from the net
have been enough to undo any gains from a cleaner syntax (assuming it is
cleaner). No Python either here, obviously, nor HAML or SLIM for templating.
Irony: they've been invented in the Ruby community which somewhat prides
itself of using a language with a better syntax than Python (I second that,
Python looks too much like a C with defs which is maybe the reason for its
success: familiarity.)

~~~
CrLf
Whenever I see someone using significant whitespace as a downside of any
language, I can't avoid thinking "man... I wouldn't like to see your code..."

~~~
drabiega
My main gripe with significant white space is that it forces a specific level
of formatting that is generally less attractive and readable then what I would
otherwise use.

~~~
CrLf
Please elaborate. Usually, significant whitespace only forces code at the same
nesting level to have the same indentation, it doesn't specify what that
indentation should be.

~~~
spoiler
I dislike significant whitespaces because when there's a lot of code that has
multiple nesting levels it becomes a bit hard to follow. I like it when my
code has a beginning and and ending token ({ and } in JS/C/C++ or `begin` and
`end` in Ruby). Whilst writing CS I found myself writing `# end` a lot.

Also, not to mention (maybe my editor lacks this feature) I like using ^M to
jump from end to beginning braces of blocks, and I can't seem to do that in
CS.

However, all of these arguments just boil down to "this is my _personal_
preference"

------
pjmlp
I never got the point of all these alternative languages.

I rather use the real thing without any extra layers.

~~~
retrogradeorbit
So you do all your coding in assembly language? Respect!

~~~
pjmlp
I used to, kid.

Back when portability didn't matter to me and languages like Pascal and C only
had compilers that produced blooty slow as molasses code.

The thing is, JavaScript is portable.

------
bayesianhorse
Coffeescript is just a short-hand for best practices javascript. It enhances
readability and consciseness.

But nothing more. Bad (or neutral) practice is still possible in coffeescript.
Mixing coffeescript and javascript files is easy. Classes can be defined any
way you please (if you don't mind using something other than the "class"
keyword).

I think the only reason for me to switch to something else from coffeescript
is if some similar language where to get a nicer type system exactly right.
I'm not holding my breath though.

------
datashaman
Purescript FTW! :)

------
pawelkomarnicki
Meh, he doesn't like Coffeescript, who cares? Why all the fanfares and huge
deal? :-)

------
MaybiusStrip
Programming language wars over languages that have significant differences are
often silly, the whole coffeescript vs JS debate is just ludicrous.

------
kra34
That's crazy talk, next thing you'll be saying we don't need AngularJS to make
web applications.

------
danabramov
RX is awesome by the way.

