Here’s the Deal

LiveScript vs Erlang

17 16

93 52

When comparing LiveScript vs Erlang, the Slant community recommends Erlang 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?” Erlang is ranked 40th while LiveScript is ranked 67th. The most important reason people chose Erlang is:

Erlang has strong roots with the telecom industry in which concurrent processes are normal. It's designed to be concurrent, to be used for distributed computing and to be scalable.

Ranked in these QuestionsQuestion Ranking

Common Questions

What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?

Pros

Pro
Designed for High-level functional code

LiveScript has terse syntax for common functional operations like map, and ships with a library, prelude.ls, with many of the functions most commonly used by functional programmers.

Pro
Good amount of programmer flexibility

There's a huge range of features that can make common tasks faster.

Pro
ECMA 6 Features

It is the declared goal of LiveScript’s creators to track ECMAScript 6. Hence, the language gives you ECMAScript 6 plus type annotations (which are optional).

LiveScript's module syntax is currently a bit behind the ECMAScript 6 specification (something that will be fixed eventually). It supports two module standards: CJS (Node.js) and AMD (RequireJS).

Pro
Fixes coffeescript scoping issues

= is used to declare variables in the current scope, in order to redeclare variables of outer scope := is used. This way bugs are reduced.

Pro
Supported by WebStorm and Visual Studio

Pro
Built from the ground up with concurrency and distributed computing in mind

Erlang has strong roots with the telecom industry in which concurrent processes are normal. It's designed to be concurrent, to be used for distributed computing and to be scalable.

Pro
Fault-tolerant

Fault tolerance means that a system has the property to continue operating even though one or more components have failed.

For Erlang systems, this means that the system is kept running even if for example a user has to drop a phone call rather than forcing everyone else to do so.

In order to achieve this, Erlang's VM gives you:

Knowledge of when a process died and why that happened
The ability to force processes to die together if they depend on each other and if one of them has a fault.
A logger that logs every uncaught exception
Nodes that can be monitored so that you find out when they go down
The ability to restart failed processes (or groups of them)

Pro
Upgrade code without stopping the system

In a real-time system it may not be possible to stop the system in order to implement code upgrades. For these cases Erlang gives you dynamic code upgrade support for free when using OTP. The mechanism is very easy to understand and works as follows:

Start the app
Edit the code
Recompile

That's all that is needed, the app updates with the new code while it's still running and tests are run automatically.

Pro
Great for writing distributed applications

Erlang is made to be parallel and distributed. Because it's very easy to write code that uses multiple processor cores, it's also very easy to write applications that span multiple servers.

Pro
Battle proven

Erlang has been used in production for more than 20 years now. During that time it has proven itself over and over again that works great in both small startups and large-scale enterprise systems.

Erlang has been used extensively by Ericsson themselves. For example, the AXD301 ATM, which is one of Ericsson's flagships is probably the largest Erlang project ever with more than 1.1 million lines of Erlang code.

Pro
Light processes

Erlang's processes have very little overhead (about 500 bytes per process). This means that a huge amount of processes can be created, even on older machines.

Pro
Consistency across platforms

Erlang's processes run in a complete independent way from the OS (they aren't managed by the OS scheduler neither). This means that programs written in Erlang will run exactly the same way regardless of the operating system or platform.

Ad
Cons

Con
Strong functional lean

LiveScript is designed to be a high level functional language. For people who prefer a more imperative approach it can be hard to get used to.

Con
Compiles to unreadable javascript

JSON.stringify(
each(upCaseName)(
sortBy(function(it){
  return it.id;
})(
(function(){
  var i$, ref$, len$, ref1$, j$, len1$, ref2$, results$ = [];
  for (i$ = 0, len$ = (ref$ = table1).length; i$ < len$; ++i$) {
    ref1$ = ref$[i$], id1 = ref1$.id, name = ref1$.name;
    for (j$ = 0, len1$ = (ref1$ = table2).length; j$ < len1$; ++j$) {
      ref2$ = ref1$[j$], id2 = ref2$.id, age = ref2$.age;
      if (id1 === id2) {
        results$.push({
          id: id1,
          name: name,
          age: age
        });
      }
    }
  }
  return results$;
}()))));

Con
Eccentric syntax

Erlang's syntax may feel very strange to 99% of programmers who have never used it. This is because it does not share any similarities or common syntax definitions that are found in all the other languages that are used today.

Con
Useful in only one niche

Erlang is not really a general purpose language. It has a very special and well-defined niche where it towers above everything else. It's specialized in scalability and in distributed applications. Which is not necessarily a bad thing per se, but it still lacks and falls behind other languages when it needs to do things outside it's niche.