Go vs. Elixir

Get help choosing one of these Get news updates about these tools


Favorites

309

Favorites

164

Hacker News, Reddit, Stack Overflow Stats

  • 10.3K
  • 7.6K
  • 33.8K
  • -
  • 1.12K
  • 6.34K

GitHub Stats

Description

What is Go?

Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.

What is Elixir?

Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain.

Pros

Why do developers choose Go?
  • Why do you like Go?

    Why do developers choose Elixir?
  • Why do you like Elixir?

    Cons

    What are the cons of using Go?
    Downsides of Go?

    What are the cons of using Elixir?
    Downsides of Elixir?

    Companies

    What companies use Go?
    718 companies on StackShare use Go
    What companies use Elixir?
    135 companies on StackShare use Elixir

    Integrations

    What tools integrate with Go?
    50 tools on StackShare integrate with Go
    What tools integrate with Elixir?
    9 tools on StackShare integrate with Elixir

    What are some alternatives to Go and Elixir?

    • JavaScript - Lightweight, interpreted, object-oriented language with first-class functions
    • PHP - A popular general-purpose scripting language that is especially suited to web development
    • HTML5 - 5th major revision of the core language of the World Wide Web
    • Python - Python is a clear and powerful object-oriented programming language, comparable to Perl, Ruby, Scheme, or Java.

    See all alternatives to Go

    Latest News

    Go 1.10 is released
    Hello, 中国!
    Participate in the 2017 Go User Survey
    Elixir v1.6 released
    What's new in Elixir - Dec/17
    Major Client Update For Elixir


    Interest Over Time


    Get help choosing one of these

    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

    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

    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

    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.