JavaScript vs CoffeeScript

If you are looking to create web projects, you will have to learn Javascript in order to develop the client side code. If you learn the foundations of programming in JavaScript you can reapply that education later in building web applications.

If you run a web browser you already have JavaScript installed and can get started right away. Modern browsers such as Chrome also have very powerful programming consoles built into them.

Aside from the browser console, you can also use online Javascript playgrounds such as JS Bin and JS Fiddle. Even from a tablet.

With Node.js, it is now possible to run JavaScript as a web server. This would allow you to be able to create server based applications sooner than would if you had to learn a separate programming language as well for server side code.

As JavaScript is the only language supported by web browsers it puts it in the unique situation of being the only programming language that's available on both the client side and server side.

While it's easy to argue that Python will give you instant gratification, JavaScript is far better in this regard. Make a small change to a page and it's immediately visible in the browser. You can throw in a JavaScript library like jQuery with minimal fuss.

While certainly not the only language with these features, this pro alone is so powerful that it compensates for most of JavaScript's problems. You'll learn to use closures and higher-order functions well in JavaScript, because you have to. And then you can generalize this knowledge to any other language that has these, and the good ones do.

By using the UI capabilities in HTML and CSS you can develop substantial applications with graphical interfaces more quickly and with less effort than in other languages which would require you to learn a windowing library.

Building a useful application is one of the best ways to learn a new language and because of the low learning curve for creating applications you can create more substatial programs and learn more practical programming priciple faster.

JavaScript has one of the largest programming ecosystems, as shown by the being the most popular language for projects on GitHub. As there are so many projects written in JavaScript there are lots of libraries available to build off of and many of them are written to be easy to use and integrate into other projects.

There are also lots of resources available for learning JavaScript. Other than traditional tutorials, language learning sites such as Codecademy have JavaScript courses. The Mozilla Developer Database also serves as a great resource for learning about the standard libraries built into JavaScript.

After learning Javascript, you will feel at home in other languages as C-like syntax is very common.

JSON is arguably a "must-learn". With JS, that's one less additional syntax to learn.

Has a built in debugger with break points, watches that work on local values, and a console that you can use to edit anything at any time. Both in the browser (eg: Chrome), and server (eg: Nodejs).

If you're looking for a career as a developer, JavaScript is the place to focus your attention. There is a huge demand for good developers especially in frameworks such as React and Angular.

With codepen.io and other prototyping tools, you can learn Javascript from a mobile device. You don't even need a computer. It can be learned from an internet cafe or public library.

By setting a few ground-rules (effectively coding in a subset of JS), JS is one of the simplest languages to learn (requiring very few must-learn prerequisite concepts).

Opens the door to native application development as well as just websites. Use with React Native, Weex or Quasar (Vue), PhoneGap or Cordova, NativeScript... (etc) to build native apps. Use mostly the same code base for multi-platform and web.

Flow, JSHint/ESLint, Babel, npm, etc.

Modern JS has made great strides, and can be targerted to older (or non-standard) browsers using Babel. There are new language constructs that can make programming in JS comfortable.; e.g.: async / await ( <3 ).

May also be a con.

Being object oriented, it supports the predominate and powerful programming approach. Being prototype based, it provides an intuitive approach to OOP. Whereas other popular languages use classes, which focus on thinking in the abstract, Javascript's prototypes allow you to focus on thinking in the concrete.

For example, in a prototypical language, you think of a rectangle, and define it. You now have a rectangle. Let's say you want a red rectangle, you copy the rectangle and give it the property red. Want a blue one? Copy rectangle again give it a blue. Big blue rectangle? Copy blue rectangle and make it big. In a class-based language, first you describe a rectangle, describe a red rectangle as a type of rectangle, describe blue and big blue rectangles, and now that you have described them, you must create instances of them, and only then do you have the rectangles. Essentially: Classes are factories for objects, prototypes are objects themselves, and the latter method was created to be more intuitive, which is particularly advantageous to beginners.

JS/ES is in the running for the fastest interpreted language given the optimizations and JIT integration of popular implementations. On the other hand, it fails utterly when compared with compiled (to native or VM code) languages.

Coding an immersive 3D game can retain the attention of new programmers. ncsoft/Unreal.js.

JavaScript usually tops the lists for most popular languages in use today and rightly so. It's used almost everywhere and it's in high demand, making it very easy to find a job for anyone who knows JavaScript. This helps make it desirable for a first language, as it will often be used in the future.

Because it runs in many different environments, it is the most used language in the world.

CoffeeScript is the most popular of the compile to Javascript languages, so long term support is much less of a worry than with others.

It also means there are many plugins and tools for integrating it into many different build systems, giving it it nearly universal support.

Javascript is a very verbose language so CoffeeScript's goal is to lighten it to make it less tedious.

Various design choices are built around making CoffeeScript more terse with things like optional parenthesis in function calls, cleaner function declarations, no curly braces, and significant white space. Because Javascript can get pretty deeply nested at times, having a lightweight syntax helps with readability.

The result is a language with a minimalistic syntax with lots of syntax sugar.

With CoffeeScript, there's never really a question of what is going on. If you're worried that something went wrong in the compilation process, the output is very human readable and mostly 1 to 1 with the CoffeeScript code, making debugging easier as the code that is being executed by the interpreter can be double checked.

The golden rule of CoffeeScript is: "It's just JavaScript". The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly from CoffeeScript (and vice-versa). The compiled output is readable and pretty-printed, passes through JavaScript Lint without warnings, will work in every JavaScript runtime, and tends to run as fast or faster than the equivalent handwritten JavaScript.

Passing functions as callbacks is central to how Javascript is written, but the default syntax for functions is very verbose and hard to read. Various CoffeeScript syntax decisions help with ease of writing and reading functions.

The most obvious change is that the function keyword is changed from function to ->. Writing out the word function is very clunky especially when you need to use multiple nested functions.

One of the more opinionated choices of CoffeeScript is the use of significant whitespace, and optional parens around function arguments. While this can be used poorly, it can also be used to great effect with nested functions. For example, a function that takes an object that defines anonymous functions will end in a mess of parens and curly braces:

asyncAction({
  success: function(data){ /* handle data */ },
  error: function(error){ /* handle errors */ }
});

In CoffeeScript you could rewrite this as:

asyncAction
  success: (data) -> /* handle data */
  fail: (error) -> /* handle errors */

Other helpful features are automatic returning of the last statement to make short anonymous functions easier so (a, b) -> a+b would replace function (a, b) { return a+b; }, as well as binding functions to the current context object with =>.

CoffeeScript adds syntax that is not only more terse than javascript, smoothing over the rough edges, but also enforces a more human readable syntax to the point where a non-programmer can understand some logic.

Many programmers that are not use to coffeescripts syntax will find it foreign if they don't read the single page API, but generally it is quick to understand and although self documenting code is a myth coffeescript is definitely very close.

if hungry then eat food for food in fridge when food isnt poison and it isnt bedtime

Seems a lot more concise and comprehensible to many programmers and most others than the alternative syntax:

var food, i, len;

if (hungry) {
  for (i = 0, len = fridge.length; i < len; i++) {
    food = fridge[i];
    if (food !== poison && it !== bedtime) {
      eat(food);
    }
  }
}

With source maps, you can get the proper location of where an error occurred directly in precompiled code, making it easier to debug without the tedious step of translating the compiled code back to the original code in your head.

Having indention-based code blocks is particularly helpful in JavaScript because of its functional callback based nature. In JavaScript you find yourself writing functions within object and passing functions to functions. You can find statements ending with a confusing melange of braces like )}})}). With significant whitespace, most of the needs for braces go away.

Even for loops and if statements. For example, to get mapped array, you don't have to use any Array methods, just the language features:
food = ( stuff for stuff in fridge when stuff.isEatable() )

Skip the documentation build, just write documentation with literate CoffeeScript.

CoffeeScript has a literate mode which let's you use markdown (used by almost everything, such as reddit, github, stack exchange, etc) with code indented how you would normally in markdown and simply enables you to run the code.

This enables you to quickly write FORMATTED, custom documentation that's easily displayed with no build step for the documentation.

Because Javascript functions can take variable amounts of parameters, it is helpful to be able to use splats to extract an array of arguments in a function.

For example, if you have a function like: (a, b, rest...) ->any amount of parameters sent to the function after a, b will be stored in an array in the variable rest. You can also put splats at the start or middle of the arguments list, such as (a, middle..., b) ->.

When calling a function you can use a splat to apply an array as arguments as well.

CoffeeScript was created by a Ruby programmer and a number of syntax features are modelled on Ruby equivalents, so will be familiar to Ruby programmers. For example, implicit returns, i.e. the last variable of each function is implicitly returned, so "return" keyword need not be present.

Easy to read and easy to work with structures like list.