When comparing CoffeeScript vs Clojure, the Slant community recommends Clojure for most people. In the question“What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?”Clojure is ranked 11th while CoffeeScript is ranked 52nd. The most important reason people chose Clojure is:

Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default.
State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity).

Pros

Pro

Lightweight syntax

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.

Pro

Compiles to readable Javascript

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.

Pro

Syntax for humans, not compilers.

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:

Pro

Widely used

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.

Pro

It's just JavaScript

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.

Pro

Source maps allow you to debug code in CoffeeScript

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.

Pro

Significant whitespace

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.

Pro

Function syntax is great for callbacks

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:

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

Pro

Splats

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.

Pro

Everything is an expression

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

Pro

Extremely easy to document with literate coffeescript

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.

Pro

Maintainable code

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

Pro

Familiar to Ruby programmers

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.

Pro

Default choice for Ruby on Rails

Pro

Immutability is the default

Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default.State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity).

Pro

Minimal syntax

Being a LISP, programs are simple: they're just functions and data. That it doesn't get bogged down with syntax or the loftier FP concepts like monads makes it one of most approachable functional languages for beginners.

Pro

Tries to solve problems as simply as possible

Simplicity is one of the pillars on which Clojure is built. Clojure tries to solve many problems in software development as simply as possible. Instead of building complex interfaces, objects or factories, it uses immutability and simple data structures.

Pro

Good for writing concurrent programs

Since Clojure is designed for concurrency, it offers things like Software Transaction Memory, functional programming without side-effects and immutable data structures right out of the box. This means that the development team can focus their energies on developing features instead of concurrency details.

Pro

Huge ecosystem of libraries to work with

There's a very large ecosystem of high-quality Clojure libraries which developers can use. One example is Incanter. It's a great data analytics library and a very powerful tool for dealing with matrices, datasets and csv files.

Pro

Cross platform

Clojure compiles to JVM bytecode and runs inside the JVM. This means that applications written in Clojure are cross-platform out of the box.

Pro

Dynamic language

A superb data processing language. While rich type and specification systems are available they are optional.

Pro

Rich Hickey

The creator is so awesome, he's a feature. Just look up his talks and see why.

Pro

Extensible

Clojure has an elegant macro system which enables language additions, Domain-specific languages (DSLs), to be created much easier than most other languages (with the exception of Racket, perhaps).

Pro

Great tool used in automating, configuring and managing dependencies available

Leiningen is a very useful tool for Clojure developers. It helps wiht automation, configuration and dependency management. It's basically a must for every Clojure project.

Pro

No C/Java syntax

Refreshing, BTW!

Pro

Game is available with which you can learn Clojure

Nightmod is a tool used to make "live-moddable" games. It displays the game's code while you are playing and allows you to inject new code using Clojure. This can be a fun and useful experience for people trying to learn Clojure.

Ad

Cons

Con

Terse syntax can lead to ambiguity

It can sometimes be hard to be sure of what CoffeeScript will compile down to because of the optional parentheses and significant white spacing. Over multiple lines the same statement can be written in many different ways, and it's not always clear what the intended interpretation is.

For example:foo bar and hello world can compile to either:

foo(bar) && hello(world)

foo(bar && hello(world))

Con

Initializing a variable and assigning it are essentially the same thing

Because of how variables are initialized and reassigned in CoffeeScript, it becomes very easy to accidentally overwrite a variable as the codebase increases. As complexity increases, the only way to safely create a variable is by pressing Ctrl + F and by examining the current file to ensure that there's no conflict.

Con

Last expression is returned by default

While this is a pro for small functions, it requires self-discipline to check if unnecessary overheads are introduced:

eat_full = ->
for food in fridge
break if full
cook food if food.requires_cooking()
eat food

This will return array of eat function results. Can be fixed by adding empty return at the end.

Con

Confusing error messages

Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it.

Con

Syntax can be alien / jarring for those used to other Lisps

Perhaps some may consider this attribute an advantage, but I do not. Clojure does not attempt to maintain significant compatibility with other Lisps. So, if you already know a Lisp or are used to the way Lisp works in general, you'll probably be confused if you take a look at Clojure. See these resources for more details on this subject:

Alternative Products

Each month, over 2.8 million people use Slant to find the best products and share their knowledge. Pick the tags you’re passionate about to get a personalized feed and begin contributing your knowledge.