Get Advice Icon

Need advice about which tool to choose?Ask the StackShare community!

Elixir
Elixir

1.9K
1.8K
+ 1
988
Go
Go

7.6K
6.1K
+ 1
2.7K
Add tool

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.

Elixir vs Go: What are the differences?

Elixir: Dynamic, functional language designed for building scalable and maintainable applications. 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; Go: An open source programming language that makes it easy to build simple, reliable, and efficient software. 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.

Elixir and Go can be primarily classified as "Languages" tools.

"Concurrency", "Functional" and "Erlang vm" are the key factors why developers consider Elixir; whereas "High-performance", "Simple, minimal syntax" and "Fun to write" are the primary reasons why Go is favored.

Elixir and Go are both open source tools. Go with 60.4K GitHub stars and 8.36K forks on GitHub appears to be more popular than Elixir with 15.6K GitHub stars and 2.22K GitHub forks.

According to the StackShare community, Go has a broader approval, being mentioned in 901 company stacks & 606 developers stacks; compared to Elixir, which is listed in 177 company stacks and 190 developer stacks.

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.

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.
Get Advice Icon

Need advice about which tool to choose?Ask the StackShare community!

Why do developers choose Elixir?
Why do developers choose Go?

Sign up to add, upvote and see more prosMake informed product decisions

Sign up to add, upvote and see more consMake informed product decisions

What companies use Elixir?
What companies use Go?

Sign up to get full access to all the companiesMake informed product decisions

What tools integrate with Elixir?
What tools integrate with Go?

Sign up to get full access to all the tool integrationsMake informed product decisions

What are some alternatives to Elixir and Go?
Erlang
Some of Erlang's uses are in telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance. OTP is set of Erlang libraries and design principles providing middle-ware to develop these systems.
Clojure
Clojure is designed to be a general-purpose language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language - it compiles directly to JVM bytecode, yet remains completely dynamic. Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system.
Ruby
Ruby is a language of careful balance. Its creator, Yukihiro “Matz” Matsumoto, blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.
Rust
Rust is a systems programming language that combines strong compile-time correctness guarantees with fast performance. It improves upon the ideas of other systems languages like C++ by providing guaranteed memory safety (no crashes, no data races) and complete control over the lifecycle of memory.
Haskell
See all alternatives
Decisions about Elixir and Go
Tim Abbott
Tim Abbott
Founder at Zulip · | 9 upvotes · 13.4K views
atZulipZulip
Python
Python
Go
Go

We've been a big fan of Python ever since we adopted it for my first startup, Ksplice. But it's been an absolutely ideal tool for Zulip, which is now one of the leading alternatives to Slack. Zulip is 100% open source software, with ~10K stars on GItHub. And being written in idiomatic Python has been really helpful for our open source project, because it's such an accessible language: Any programmer can learn Python quickly. And that means we're not restricted to e.g. "folks who are excited about contributing to Zulip and ALSO know Go".

I've linked to a blog post I wrote on Python's awesome new static type system, which fixes the main complaint one might have about using Python for a large codebase, which has a lot more perspective, as well as some commentary on our Python 3 migration.

See more
Antonio Sanchez
Antonio Sanchez
CEO at Kokoen GmbH · | 14 upvotes · 256.6K views
atKokoen GmbHKokoen GmbH
PHP
PHP
Laravel
Laravel
MySQL
MySQL
Go
Go
MongoDB
MongoDB
JavaScript
JavaScript
Node.js
Node.js
ExpressJS
ExpressJS

Back at the start of 2017, we decided to create a web-based tool for the SEO OnPage analysis of our clients' websites. We had over 2.000 websites to analyze, so we had to perform thousands of requests to get every single page from those websites, process the information and save the big amounts of data somewhere.

Very soon we realized that the initial chosen script language and database, PHP, Laravel and MySQL, was not going to be able to cope efficiently with such a task.

By that time, we were doing some experiments for other projects with a language we had recently get to know, Go , so we decided to get a try and code the crawler using it. It was fantastic, we could process much more data with way less CPU power and in less time. By using the concurrency abilites that the language has to offers, we could also do more Http requests in less time.

Unfortunately, I have no comparison numbers to show about the performance differences between Go and PHP since the difference was so clear from the beginning and that we didn't feel the need to do further comparison tests nor document it. We just switched fully to Go.

There was still a problem: despite the big amount of Data we were generating, MySQL was performing very well, but as we were adding more and more features to the software and with those features more and more different type of data to save, it was a nightmare for the database architects to structure everything correctly on the database, so it was clear what we had to do next: switch to a NoSQL database. So we switched to MongoDB, and it was also fantastic: we were expending almost zero time in thinking how to structure the Database and the performance also seemed to be better, but again, I have no comparison numbers to show due to the lack of time.

We also decided to switch the website from PHP and Laravel to JavaScript and Node.js and ExpressJS since working with the JSON Data that we were saving now in the Database would be easier.

As of now, we don't only use the tool intern but we also opened it for everyone to use for free: https://tool-seo.com

See more
Nitzan Shapira
Nitzan Shapira
at Epsagon · | 16 upvotes · 228K views
atEpsagonEpsagon
Python
Python
Serverless
Serverless
npm
npm
Node.js
Node.js
Go
Go
Java
Java
GitHub
GitHub
AWS Lambda
AWS Lambda

At Epsagon, we use hundreds of AWS Lambda functions, most of them are written in Python, and the Serverless Framework to pack and deploy them. One of the issues we've encountered is the difficulty to package external libraries into the Lambda environment using the Serverless Framework. This limitation is probably by design since the external code your Lambda needs can be usually included with a package manager.

In order to overcome this issue, we've developed a tool, which we also published as open-source (see link below), which automatically packs these libraries using a simple npm package and a YAML configuration file. Support for Node.js, Go, and Java will be available soon.

The GitHub respoitory: https://github.com/epsagon/serverless-package-external

See more
Omar Mehilba
Omar Mehilba
Co-Founder and COO at Magalix · | 18 upvotes · 131.3K views
atMagalixMagalix
Kubernetes
Kubernetes
Microsoft Azure
Microsoft Azure
Google Kubernetes Engine
Google Kubernetes Engine
Amazon EC2
Amazon EC2
Go
Go
Python
Python
#Autopilot

We are hardcore Kubernetes users and contributors. We loved the automation it provides. However, as our team grew and added more clusters and microservices, capacity and resources management becomes a massive pain to us. We started suffering from a lot of outages and unexpected behavior as we promote our code from dev to production environments. Luckily we were working on our AI-powered tools to understand different dependencies, predict usage, and calculate the right resources and configurations that should be applied to our infrastructure and microservices. We dogfooded our agent (http://github.com/magalixcorp/magalix-agent) and were able to stabilize as the #autopilot continuously recovered any miscalculations we made or because of unexpected changes in workloads. We are open sourcing our agent in a few days. Check it out and let us know what you think! We run workloads on Microsoft Azure Google Kubernetes Engine and Amazon EC2 and we're all about Go and Python!

See more
Conor Myhrvold
Conor Myhrvold
Tech Brand Mgr, Office of CTO at Uber · | 24 upvotes · 2M views
atUber TechnologiesUber Technologies
Jaeger
Jaeger
Python
Python
Java
Java
Node.js
Node.js
Go
Go
C++
C++
Kubernetes
Kubernetes
JavaScript
JavaScript
Red Hat OpenShift
Red Hat OpenShift
C#
C#
Apache Spark
Apache Spark

How Uber developed the open source, end-to-end distributed tracing Jaeger , now a CNCF project:

Distributed tracing is quickly becoming a must-have component in the tools that organizations use to monitor their complex, microservice-based architectures. At Uber, our open source distributed tracing system Jaeger saw large-scale internal adoption throughout 2016, integrated into hundreds of microservices and now recording thousands of traces every second.

Here is the story of how we got here, from investigating off-the-shelf solutions like Zipkin, to why we switched from pull to push architecture, and how distributed tracing will continue to evolve:

https://eng.uber.com/distributed-tracing/

(GitHub Pages : https://www.jaegertracing.io/, GitHub: https://github.com/jaegertracing/jaeger)

Bindings/Operator: Python Java Node.js Go C++ Kubernetes JavaScript OpenShift C# Apache Spark

See more
Prometheus
Prometheus
Logstash
Logstash
nginx
nginx
OpenResty
OpenResty
Lua
Lua
Go
Go

At Kong while building an internal tool, we struggled to route metrics to Prometheus and logs to Logstash without incurring too much latency in our metrics collection.

We replaced nginx with OpenResty on the edge of our tool which allowed us to use the lua-nginx-module to run Lua code that captures metrics and records telemetry data during every request’s log phase. Our code then pushes the metrics to a local aggregator process (written in Go) which in turn exposes them in Prometheus Exposition Format for consumption by Prometheus. This solution reduced the number of components we needed to maintain and is fast thanks to NGINX and LuaJIT.

See more
StackShare Editors
StackShare Editors
Python
Python
Go
Go
Kubernetes
Kubernetes

Following its migration from vanilla instances with autoscaling groups to Kubernetes, Postmates began facing challenges while “migrating workloads that needed to scale up very quickly.”

The built-in Horizontal Pod Autoscaler (HPA) automatically scales the number of pods in a replication controller, deployment or replica set based on observed CPU utilization. But the challenges for Postmates is that there’s no way to configure the scale velocity of one particular cluster with an HPA.

For Postmates, which runs at least three different types of applications with distinct performance and scaling characteristics, this proved problematic.

To overcome these challenges, the team created and open sourced the Configurable Horizontal Pod Autoscaler, which allows for fine-grained tuning on a per-HPA object basis. The result is that “you can configure critical services to scale down very slowly, while every other service could be configured to scale down instantly to reduce costs.”

See more
Sebastian Gębski
Sebastian Gębski
CTO at Shedul/Fresha · | 7 upvotes · 68.2K views
atFresha EngineeringFresha Engineering
Elixir
Elixir
Phoenix Framework
Phoenix Framework
Erlang
Erlang
Credo
Credo
Hex
Hex
AppSignal
AppSignal

Another major decision was to adopt Elixir and Phoenix Framework - the DX (Developer eXperience) is pretty similar to what we know from RoR, but this tech is running on the top of rock-solid Erlang platform which is powering planet-scale telecom solutions for 20+ years. So we're getting pretty much the best from both worlds: minimum friction & smart conventions that eliminate the excessive boilerplate AND highly concurrent EVM (Erlang's Virtual Machine) that makes all the scalability problems vanish. The transition was very smooth - none of Ruby developers we had decided to leave because of Elixir. What is more, we kept recruiting Ruby developers w/o any requirement regarding Elixir proficiency & we still were able to educate them internally in almost no time. Obviously Elixir comes with some more tools in the stack: Credo , Hex , AppSignal (required to properly monitor BEAM apps).

See more
Go
Go
Python
Python
PostgreSQL
PostgreSQL
TypeScript
TypeScript
JavaScript
JavaScript
NATS
NATS
Docker
Docker
Git
Git

Go is a high performance language with simple syntax / semantics. Although it is not as expressive as some other languages, it's still a great language for backend development.

Python is expressive and battery-included, and pre-installed in most linux distros, making it a great language for scripting.

PostgreSQL: Rock-solid RDBMS with NoSQL support.

TypeScript saves you from all nonsense semantics of JavaScript , LOL.

NATS: fast message queue and easy to deploy / maintain.

Docker makes deployment painless.

Git essential tool for collaboration and source management.

See more
Vishwa Bhat
Vishwa Bhat
Fullstack Developer at Sequoia · | 10 upvotes · 4.7K views
atSequoia Consulting GroupSequoia Consulting Group
Node.js
Node.js
Go
Go
Java
Java

Our new backend micro services are primarily written in Node.js and Go and legacy systems are written in Java. For our new stack decision, we aimed to achieve greater developer productivity, low IO latency and good community so we had couple of technologies in hand to choose but finally we concluded to go for Node.js for API layer and Go for CPU/IO intensive tasks. Currently the inter-services communication is happening via REST but soon to be moved to RPC-based communication.

See more
Robert Zuber
Robert Zuber
CTO at CircleCI · | 4 upvotes · 14.4K views
atCircleCICircleCI
CoffeeScript
CoffeeScript
Hubot
Hubot
Go
Go
Slack
Slack

We have added very little to the CoffeeScript Hubot application – just enough to allow it to talk to our Hubot workers. The Hubot workers implement our operational management functionality and expose it to Hubot so we can get chat integration for free. We’ve also tailored the authentication and authorization code of Hubot to meet the needs of roles within our team.

For larger tasks, we’ve got an internal #CLI written in Go that talks to the same #API as Hubot, giving access to the same functionality we have in Slack, with the addition of scripting, piping, and all of our favorite #Unix tools. When the Hubot worker recognizes the CLI is in use, it logs the commands to Slack to maintain visibility of operational changes.

See more
John Datserakis
John Datserakis
Go
Go
PHP
PHP
Node.js
Node.js

For the backend of https://www.rsvpkeeper.com I went with Go.

My past few project have been built with Go and I'm really loving it. It was my first statically typed language after many years with PHP and Node.js - and honestly I couldn't be happier to have made the switch.

The biggest thing for me, is that with the forced declaration of types - it's made me feel like I've made a more solid backend. Sometimes with PHP I felt like a stiff breeze could knock the whole thing down. I know that's an exaggeration - but it's kinda how it feels.

Anyways, everyone knows that it almost doesn't even matter what an app is actually made with - what really matters are the design decisions you make a long the way.

See more
Dan Larsen
Dan Larsen
CTO at FlowStack · | 7 upvotes · 80K views
atFlowStack ApSFlowStack ApS
Go
Go
Rust
Rust
C
C
C++
C++

At FlowStack we write most of our backend in Go. Go is a well thought out language, with all the right compromises for speedy development of speedy and robust software. It's tooling is part of what makes Go such a great language. Testing and benchmarking is built into the language, in a way that makes it easy to ensure correctness and high performance. In most cases you can get more performance out of Rust and C or C++, but getting everything right is more cumbersome.

See more
Kamil Kowalski
Kamil Kowalski
Engineering Manager at Fresha · | 26 upvotes · 190.5K views
atFresha EngineeringFresha Engineering
Selenium
Selenium
Java
Java
Ruby
Ruby
Elixir
Elixir
JavaScript
JavaScript
Cypress
Cypress

When you think about test automation, it’s crucial to make it everyone’s responsibility (not just QA Engineers'). We started with Selenium and Java, but with our platform revolving around Ruby, Elixir and JavaScript, QA Engineers were left alone to automate tests. Cypress was the answer, as we could switch to JS and simply involve more people from day one. There's a downside too, as it meant testing on Chrome only, but that was "good enough" for us + if really needed we can always cover some specific cases in a different way.

See more
Jakub Olan
Jakub Olan
DevOps Engineer · | 17 upvotes · 19K views
ataraclxaraclx
Java
Java
Python
Python
C++
C++
Node.js
Node.js
Rust
Rust
Kotlin
Kotlin
Go
Go

In our company we have think a lot about languages that we're willing to use, there we have considering Java, Python and C++ . All of there languages are old and well developed at fact but that's not ideology of araclx. We've choose a edge technologies such as Node.js , Rust , Kotlin and Go as our programming languages which is some kind of fun. Node.js is one of biggest trends of 2019, same for Go. We want to grow in our company with growth of languages we have choose, and probably when we would choose Java that would be almost impossible because larger languages move on today's market slower, and cannot have big changes.

See more
Interest over time
Reviews of Elixir and Go
Review ofElixirElixir

i've give a try to Ruby, Crystal, Python and GO, and yeah, for web development i use Elixir-Phoenix, because idk why just amazing, my phoenix app is very stable (comparing to api that written in other language), Ruby is slow, Crystal has unstable API, GO, umm yeah, you need too complicated (i use golang for microservice)

Review ofGoGo

Go has been a joy to work with. Performance is often 30x of what we used to see with Python. It's a performant and productive programming language: https://getstream.io/blog/switched-python-go/

How developers use Elixir and Go
Avatar of Karma
Karma uses GoGo

The first time I actually started using Go was for software on our devices. So on our hotspots we have some custom software running in the firmware. For the first device, that was actually completely built by our manufacturer. But for the second generation most of the parts are built by us in-house and we needed a way to quickly develop software for the device. But we don't have any C programmers in-house, so we were actually looking for something that basically sits in between the friendliness of Ruby, but the performance and the ability to be deployed on an embedded system which you get with C. That's basically what led us to Go and it's been awesome for that. It works so well and so great. Since it works so great, it pushed us into looking into whether we should start using this for some backend services as well.

Avatar of Flutter Health Inc.
Flutter Health Inc. uses GoGo

The following basic API endpoints are implemented on the server written in Go:

  • Authorization (Sign Up, Sign In)
  • Update user profile
  • Community: add post, like post, add comment, delete post, add reply to comment
  • Self-diagnosis: send data from the app to the server
  • Journal: send user data from the app to the server
  • Add groups of community
  • Report post, report comment, report reply
  • Block user
Avatar of Zinc
Zinc uses GoGo

We wrote our own image processing, resizing, and snapshotting service in Go to allow our clients to send photos and GIFs to each other. Files are stored in S3, resized on the fly using OpenCV, and then cached in GroupCache before being served to clients.

Go allows it all to be quite fast and efficient, and entirely non-blocking on uploads!

Avatar of Diggernaut LLC
Diggernaut LLC uses GoGo

Our main web scraping engine is built usign Golang because of the way how efficiently and fast this language is. Also out compilation facility let people who dont know Golang build fast as flash scrapers to run ourside of our platform without any knowledge in programming in Golang.

Avatar of Refractal
Refractal uses GoGo

For some of our more taxing parts of our applications, something able to handle high I/O load quickly and with fast processing is needed. Go has completely filled that gap, allowing us to break down walls that would've been completely impossible with other languages.

Avatar of Provide Booking
Provide Booking uses ElixirElixir

Huge boon to productivity when coupled with Phoenix. Moreover, it has made background jobs and all the unseen aspects of a business easily abstracted.

Avatar of Walter
Walter uses ElixirElixir

Knowledge collection, collation, and enrichment. Business logic.

Avatar of Ruben Timmerman
Ruben Timmerman uses ElixirElixir

For some internal tools like our email deliverability monitor

Avatar of Ryan Jennings
Ryan Jennings uses ElixirElixir

language used by phoenix framework

Avatar of olenderhub
olenderhub uses ElixirElixir

Elixir and Phoenix are awesome.

How much does Elixir cost?
How much does Go cost?
Pricing unavailable
Pricing unavailable