CoffeeScript vs ClojureScript

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.

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.

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.

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);
    }
  }
}

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 =>.

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.

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() )

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.

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.

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.

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

Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding! Every time you save your ClojureScript source file, the changes are sent to the browser so that you can see the effects of modifying your code in real time.

Lispness makes ClojureScript trivial to comprehend after an initial learning overhead.

Clojure and ClojureScript are designed to be able to interact with their host. So the language by design makes it is easy to use existing JS libraries.

Google's Closure Library converts regular JavaScript into a highly optimized form - including dead code analysis/elimination. It can even remove pieces of unused code from 3rd party libraries (eg, if you import jQuery but only use one function, Google Closure includes only that piece).

Clojure is also able to run web servers, so one can reap similar benefits to NodeJS in terms of sharing code between client and server.

Both Leiningen and Boot are great build tools that manage code dependencies and deployment.

ClojureScript has superb wrappers around React.js (see Reagent) that make building single-page apps a breeze. With figwheel, it's a web dev experience unlike any other -- hotloaded code, repl interaction, and instantly reflected changes make good development fun and fast. You can add things like Garden to make CSS-writing part of the same holistic experience and suddenly all development is a pleasant, smooth process.

From the creator of Clojure:
Spec is a new core library (Clojure 1.9 and Clojurescript) to support data and function specifications in Clojure.
Writing a spec should enable automatic: Validation, Error reporting, Destructuring, Instrumentation, Test-data generation and Generative test generation.