Johanna Larsson built the super cool Hex Diff tool for the Elixir community. What does it do?

In short, you input any Hex package name and a version range, and it will generate a highlighted git diff for you, right there in your browser. Not only that, but you can also share the link to the diff, and even highlight a specific row.

In this post on her blog, Johanna goes into the details of how she built the project, how it works, and issues she ran into along the way.

Lars Wikman:

The Lumen Project is an alternative implementation of the Erlang VM, more known as the BEAM. It is designed to work in WebAssembly with the specific goal of bringing Elixir and Erlang to the browser with minimal overhead, tightly compiled rather than porting a full VM. Can it replace JS for some developers?

An excellent article, highly recommended. Lars hangs out in our community chat and suggested we do an episode with the Lumen team. Talks are underway, so stay tuned for that.

This is a great resource to have at your disposal while reading the official Elixir docs.

While working throughout the guide - there were multiple positions where the ideolog seemed overwhelming resulting to various logical bugs because of shorthand syntax mismatch. There is no repository available to cross-check your results either to fix your bugs. Hence - I thought it would be nice to have this as a reference guide to how you need to implement your project.

I need this in my life.

Jerod is joined by Chris and Desmond (co-hosts of the ElixirTalk podcast) to catch up on what’s moving and shaking in the Elixir and Phoenix communities. We discuss what’s attractive about Elixir, what it means to have the language finalized, why folks are so excited by Phoenix LiveView, the ambitious new Lumen project that’s bringing Elixir to WebAssembly, and more.

Jonathan Clem:

What I’m most excited for with Phoenix LiveView isn’t necessarily the cool technology that it really is, but more the freedom that it gives me to quickly implement nice-to-have features that would otherwise be too much work to bother with.

I’m having a lot of fun with Svelte right now, but it’s probably time for me to turn my attention to LiveView. Where there’s enough smoke, there’s usually 🔥…

Conventional template languages like EEx use a form of interpolation to embed a programming language into a markup language, which can result in some ugly code that can be difficult to write and debug.

Temple is written using pure elixir.

There are some good ideas here, for sure. (Click through for code samples.)

My concern with this (and with pretty much all non-HTML style template languages) is cognitive overhead for folks who’d rather be writing HTML. That being said, if I were creating a web app from scratch all by my lonesome, I’d 💯% give Temple a go.

The Discord team bumped up against some limitations of the BEAM (Erlang’s virtual machine) when dealing with rather large data structures:

The double-edged sword of immutable data structures is that mutations are modeled by taking an existing data structure and an operation and creating a brand new data structure that is the result of applying that operation to the existing data structure.

This meant that when someone joined a server — internally referred to as guilds — with a Member List of 100,000 members, we would have to build a new list with 100,001 members in it.

You’ll want to click through and read all of the data structures they tried to fix this problem. It’s some seriously solid engineering and I love how they continued to measure and push themselves further. Finally, they reached for Rust thanks to BEAM’s NIF feature and really scaled up the speed.

José Valim, announcing the just-released Elixir v1.9:

… releases was the last planned feature for Elixir. We don’t have any major user-facing feature in the works nor planned. I know for certain some will consider this fact the most excing part of this announcement!

This doesn’t mean the language will stop moving forward, but you’ll have to read the full announcement to get the full picture. The Releases feature looks shiny, for sure. Congrats to all involved for yet another awesome milestone!

Phoenix 1.3 introduced the idea of Contexts, which I’m generally very much in favor of. However, I wish there was a little bit more structure to the idea. It’s so open ended that I’ve found deciding where best to put a function kind of tricky, and then I frequently end up with duplicate behavior across contexts or have a hard time finding functions later on because the module they’re in made sense at the time, but it doesn’t make as much sense now.

So, I’m proposing the idea of a Primary Context and a Secondary Context.

I’ve also struggled to determine just how to use Contexts to my benefit. It seems that Devon is trying an add more structure approach whereas I have (so far) gone with a YAGNI approach.

Adam Wathan was gracious enough to invite me on Full Stack Radio to discuss why and how we built this very platform that I’m using to write and you’re using to read.

Most of the show focuses on Elixir itself, with topics ranging from pattern matching and immutability to the pipe operator and deployment. Adam also got me to confess a dirty little secret… I still don’t really know what GenServers are! 😱

Oban’s primary goals are reliability, consistency and observability. It is fundamentally different from other background job processing tools because it retains job data for historic metrics and inspection. You can leave your application running indefinitely without worrying about jobs being lost or orphaned due to crashes.

Nick Janetakis joins Jerod backstage to talk shop. We discuss how Nick is using the Changelog.com source code as a guide to build his video course platform, coding practices we’ve developed over the years, how to balance between shipping features and creating content, newsletters as the new social network, how Nick makes his videos, and a whole lot more.

Lots of goodies have landed in Elixir lately, including mix release, an official Config module, a ~U sigil for UTC datetimes, and much more. José Valim lays out all of the details in this post.

In this short Q&A, Sergiy Kukunin, an Elixir expert, shares his thoughts on why Elixir is becoming so popular, its core advantages, and its drawbacks.

Sergiy also shared this as a takeaway to getting started with Elixir.

…the syntax of Elixir has some things in common with Ruby. The languages are entirely different, but it is always good to see symbols and elements you are used to. The simplest thing is to use some of the new Elixir-compatible web-development frameworks. The most popular web framework for Elixir is Phoenix. You should definitely give it a try, especially if you are used to using Ruby on Rails. This will simplify development while still making the app faster and more reliable.

Chris McCord and team have (finally 😉) open sourced Phoenix’s much anticipated LiveView feature and Dennis Beatty has a great video/explainer on how to build a simple counter with it.

I’m watching this space very closely for future changelog.com features and can’t wait to give it a spin!

The dwyl team went “all-in” on Elixir back in 2016 and are often asked if they would make the same choice again. Here’s the TLDR of their answer:

The question of “Which Programming Language” is one we ask ourselves fairly regularly, and is the reason that lead us to discover and decide on using Elixir in 2016. We periodically survey the “up-and-coming” languages like Kotlin, Julia, Lua, etc. and keep concluding that our choice of Elixir is the one we would make again right now. Elixir is the “full package” from idea to deployment!

Click through for their full reasoning, which includes why they switched from Node.js to Elixir in the first place, Elixir’s pros/cons they’ve learned along the way, and a list of other languages they would choose given different use cases.

Mint is a new low-level HTTP client that aims to provide a small and functional core that others can build on top. Mint is connection based: each connection is a single struct with an associated socket belonging to the process that started the connection.

This looks like an excellent base layer for the Elixir community to build HTTP clients upon. Take note: The core Elixir team is so good at laying foundations like this. Plug, for example, is a near-perfect base layer for HTTP servers.

Dave Thomas:

For a while now I’ve been doing my Cassandra impersonation, telling everyone who’ll listen (and quite a few folks who won’t) that we need to be writing code in smaller chunks. I know what happens when we don’t, as I was the author of one of the largest early Rails applications (65kloc), and it became a nightmare to work with.

He doesn’t want the same thing to happen in Elixirland, so he’s released Component, which is “an attempt to make it so easy to write trivial standalone servers that people will just naturally split their applications up that way.”

This is a proof of concept, but oh what a concept! I freakin’ 💚 Elixir’s pipe operator, hope they’ll add it to JavaScript, and would trade half my kingdom to have it in Ruby.

"https://api.github.com/repos/ruby/ruby".pipe do
  URI.parse
  Net::HTTP.get
  JSON.parse.fetch("stargazers_count")
  yield_self { |n| "Ruby has #{n} stars" }
  Kernel.puts
end
#=> Ruby has 15120 stars

In this post, I’m going to demonstrate how to use GitHub Actions in an Elixir project. By the end of it, we’ll have a simple workflow that tests and checks formatting of our code.

I have a feeling we’ll be seeing a lot more “GitHub Actions for $X” posts in the coming months…

As a reminder, LiveView is an in-development feature of the Phoenix web framework that helps you create rich, interactive experiences while writing very little (ostensibly, zero) JavaScript. In Chris’ words:

Phoenix LiveView is an exciting new library which enables rich, real-time user experiences with server-rendered HTML. LiveView powered applications are stateful on the server with bidrectional communication via WebSockets, offering a vastly simplified programming model compared to JavaScript alternatives.

In the linked post, Chris shows a lot of examples of LiveView in action, demonstrating what it’s capable of.

Here’s a feature-complete snake game, in 330 LOC, which requires zero user-land JavaScript.

Impressive!

This release ships with exciting new features, most notably HTTP2 support, improved development experience with faster compile times, new error pages, and local SSL certificate generation.

I’m excited to upgrade us so we can get up and running on H2! 💪

Finally, an article that breaks Betteridge’s law of headlines!

Elixir is known for being a language made for building distributed applications that scale, are massively concurrent, and have self-healing properties. All of these adjectives paint Elixir in a grandiose light. And for good reasons! But is Elixir also a language that can be used for the more mundane tasks of this world like scripting? I think the answer is a definite yes.

I’ve been writing Elixir for a few years now, but when it comes time to script something I still reach for Ruby. Case in point, our data import routines for changelog.com (which y’all know is an Elixir app) are written in Ruby.

Why do I do this? Familiarity plays a big part. Also I find Ruby to be highly ergonomic for such tasks. Having said that, this article will make me consider trying Elixir for my next script.

Ecto 3 is right around the corner, and José Valim is blogging all about it as the release date approaches. This post is all about the breaking changes, which are few but significant. Most notably, the library will be split into two repositories: ecto and ecto_sql. Read the post to find out why.

Elixir gets its very own UI framework focused on connected devices (IoT). Scenic apps run identically across operating systems, including MacOS, Ubuntu, Nerves/Linux, and more.

Notably, Scenic does not use any browser technologies. Learn all about it in Boyd Multerer’s ElixirConf 2018 talk.