Elixir vs Go: What are the differences?

Elixir and Go are two popular programming languages known for their performance, concurrency, and scalability. Let's explore the key differences between Elixir and Go:

1. Syntax and Paradigm: Elixir is a functional programming language built on the Erlang virtual machine (BEAM) and focuses on immutability and data transformation. It has a Ruby-like syntax that prioritizes readability and expressiveness. Go is a statically typed, compiled language with a C-like syntax that emphasizes simplicity and efficiency.

2. Concurrency and Parallelism: Elixir's concurrency model is based on lightweight processes called actors, enabling massive concurrency through message passing. It provides tools like supervisors and fault-tolerant supervision trees. Go's built-in concurrency model uses goroutines and channels for efficient handling of a large number of concurrent tasks.

3. Ecosystem and Libraries: Elixir has a robust ecosystem built on Erlang's foundation, known for fault-tolerant and scalable systems. It offers libraries and frameworks for web development (Phoenix), distributed systems (Horde), and real-time communication (Presence). Go has a growing ecosystem focused on simplicity and performance, with standard libraries for networking, web development, and system programming.

4. Error Handling and Fault Tolerance: Elixir follows a "let it crash" philosophy, treating errors as normal conditions and providing mechanisms like supervisors for recovery. Go uses explicit error returns and runtime error checking, promoting graceful error handling for recovery or propagation.

5. Performance and Execution Speed: Elixir's performance is influenced by the BEAM virtual machine, optimized for concurrency and fault tolerance. It excels in handling concurrent and distributed workloads, offering scalability. Go is designed for high-performance applications, compiling into native machine code for fast startup times and efficient resource utilization.

In summary, Elixir's functional programming approach, lightweight processes, and fault-tolerant design make it suitable for building scalable and distributed systems. Go's focus on simplicity, efficiency, and built-in concurrency features make it a compelling choice for building high-performance applications.

Golang or Elixir — Help me decide

Programming Style

Go (commonly referred to as Golang) is a C-like Object Oriented language, while Elixir is a Ruby-like Functional language. The programming styles of each platform were chosen due to the intended platform usage. As a general purpose language, Go incorporates many features of languages such as C and Python, but with an exceptional concurrency layer designed to leverage modern multi-core CPUs. Elixir, first released in 2012, is based on the Erlang VM and enforces immutable data and pattern matching, but also a powerful macro system that forms the building blocks of the language itself.

The Go language incorporates first class functions, which provide for some functional capabilities. Although very C- like, including structs and pointers, Go also offers variadic functions, closures, and the ability to return multiple values from a function. Each of these features make Go more expressive. Go also provides its own limited style of pattern matching in the form of interfaces.

// invoke a closure with one parameter but returning two
func invoke(fn func(string) (int, string), msg string) (int, string) {
  return fn(msg)
}

Each of Elixir's features are designed to enable effortless development of distributed, fault-tolerant applications such as web servers and databases. Pipes are available to chain functions together, while list comprehensions, extensive enumerable functions, and streaming provide numerous ways to process lists of data easily and lazily.

# lazily output a list of words from file
File.stream!("./list_of_words.txt")
|> Enum.map(&String.trim/1)
|> Enum.each(&IO.puts/1)

Elixir also supports pattern matching binary data, which makes encoding and decoding binary packets simpler than any other programming language available today.

Runtime Speed

Go is compiled to a native binary, while Elixir is compiled to bytecode and executed on the Erlang Virtual Machine (BEAM). As such, Go produces applications that run much faster than Elixir. As a rule, Go applications will run comparative to Java applications, but with a tiny memory footprint. Elixir, on the other hand, will typically run faster than platforms such as Ruby and Python, but cannot compete with the sheer speed of Go.

Runtime and memory benchmarking (Brainf**k benchmarks)

Erlang, the platform underlying Elixir, makes numerous sacrifices in runtime speed in order to provide memory safety, native distributed messaging (clustering), and fault tolerant process management. However, additional speed can be gained where absolutely necessary by incorporating native code called "NIF's" in Elixir applications.

Go was built by Google in 2009 to replace languages such as C++. As such, it was designed as a solution to a large range of programming problems such as web servers, desktop applications, and even games. Runtime speed, therefore, is a high priority of Go.

Fault Tolerance

Elixir (and the Erlang Virtual Machine) were designed from the ground up as a fault tolerant platform. The philosophy of Elixir is "Let it crash!", meaning that an application exception should kill its process. This empowers the developer as there is much less need to write defensive code and to cater for every eventuality. Go, on the other hand, makes no assumptions about the application you are writing. Therefore, applications written in Go are not fault tolerant out-of-the-box.

Elixir provides the notion of process "Supervisors" which create new processes instantaneously when their predecessor dies. Each supervisor can be configured to kill sibling processes if necessary, so that all processes are in sync. Supervisors can also be linked as parent -> child, forming a process tree. The underlying Erlang platform has been known to achieve 99.9999999% (nine nines) reliability or (31 milliseconds of downtime per year).

Go follows the traditional defensive programming paradigms and assumes that exceptions will be handled directly. Processes that are killed due to a failure, or otherwise, must be restarted explicitly if the functionality is still required. Several syntactic constructs exist to facilitate fault handling, including the defer keyword and panic/recover.

With built-in resource alerts, automatic process respawning, process supervision strategies and node rediscovery, Elixir can, therefore, be considered more inherently fault tolerant than Go.

Concurrency

Both Go and Elixir derive CSP processes; a lightweight process methodology using very little memory. The Erlang VM uses only 618 bytes for a new raw process stack, while Go uses around 2 to 3 kilobytes. A typical raw Operating System process, used as a thread in many languages, will utilise at least one Megabyte or more of memory. Therefore, creating processes in either language is cheap on resources and make concurrent applications development very efficient.

Go concurrency focuses around Goroutines and Channels. A Goroutine is a function that can be elevated to a process status when invoked. Messages are passed in and out of processes using Channels.

Go Channels are first class message pipes that can be shared by one or more processes. "First class" means the Channel references can be passed into other functions and processes for consumption. Since Channels are shared, they contain their own mailboxes. This affords a greater amount of flexibility but at the cost of increased complexity.

func invoke(msg string) {
  fmt.Println(msg)
}
go invoke(“Within a new process”)

Go Channels can be considered a little like Events in other platforms and frameworks; you cannot guarantee who will receive the message. This provides greater flexibility but at a cost potential bugs in your applications.

A shared Channel in GoLang

Elixir concurrency follows the Actor model, which describes the notion of processing units that act on data messages. Messages are passed to processes and stored in the process mailbox. When one process sends data to another, the data is copied, meaning individual units of data cannot be modified by two processes, thus preventing data corruption. This suits Elixir as it is a Functional language.

Elixir processes are often derived from the GenServer, which is a contained module definition providing for easy management of incoming messages and state. However, like Go, Elixir also provides a means to create a process from a function invocation. Messages are passed by sending to the receiving processes PID (process id) which can exist on the local server or another server entirely; the Erlang VM makes this completely transparent.

spawn fn -> IO.puts(“within a new process”) end

Elixir messages are direct; they are sent to a specific process. While it is possible to set up a custom Events management system for anonymous message posting, the Elixir / Erlang platform favours safety over flexibility. Concurrency issues are less frequent in Elixir when compared to Go.

Message passing in Elixir

Further Reading

Here are some other topics worth exploring as you make your decision:

• Web Servers: Go provides for building web servers out-of-the-box, while Elixir provides the Rails-like Phoenix framework.
• Databases: Go was used to create InfluxDB, while the Riak NoSQL database was built with Erlang.