Beambloggers Webring

Injecting tracing the hot way

Wed, 25 Mar 2026 04:00:00 +0000

From Underjord.io: I mostly program in Elixir. So tracing is an overloaded term. This post relates to both of them and how we can use BEAM and Erlang fundamentals to do wild things for observability that wouldn’t be practical in most runtimes. Let’s load some hot code. First is a set of (experimental) updates I’ve done to my “Erlang tracing” library Entrace. Erlang’s concept of tracing is a mechanism in which you can tell the system to send you information about execution of functions that match some pattern.

Hacking on the Nerves Starter Kit in Malaga

Wed, 11 Mar 2026 04:00:00 +0000

From Underjord.io: I’m going to be speaking at ElixirConf EU in Malaga. When I got to Elixir conferences I relatively often also make sure to run a little something-something for the real heads. A Nerves thing. Touch keyboard, touch hardware, get to know people. The biggest reason for this is to make an ice-breaker for people that are attending the conf. People who would enjoy a way to engage with others up front in a practical workshop kind of way.

Shipping grayscale photos at small scale

Sun, 08 Mar 2026 04:00:00 +0000

From Underjord.io: In September of 2025 Tigris sponsored an odd effort at an unusual conference. They contributed the money for manufacturing hardware devices to be used and hacked on during Goatmire Elixir in Varberg, Sweden. These devices also used Tigris for some features. Everything about it is open source. Let’s see what it turned into. Goatmire Elixir is my (Lars') brainchild. I like the idea of a quirky event, smaller scope and people who are deeply enthusiastic about related things.

Goatmire 2, announced

Wed, 14 Jan 2026 04:00:00 +0000

From Underjord.io: Goatmire Elixir 2025 was a very dense success. The second one just got announced. I say dense. Because massive success would make it sound large. And it wasn’t a large event. 150 attendees, with speakers and volunteers we were around 200 in total. And it went incredibly well. The feedback, the surveys, the outpouring of love and appreciation were all way above what I dared hope for. People have been graciously giving me space to consider a second one but it has also been the single most requested thing ever.

Buying the Kinesis Advantage 360 keyboard was a mistake

Thu, 04 Dec 2025 06:55:00 GMT

From Angelika.me: Why this beast of a keyboard did not work for me and what I ended up using instead.

Conference Report: Goatmire Elixir 2025

Mon, 22 Sep 2025 04:00:00 +0000

From Underjord.io: The quiet was unsettling. The lack of concrete things to do was stressful. Me and my wife had been fretting and flitting around the house for most of the day making sure everything was staged, that we had the various prints, checklists were ready, lots of bags and boxes were packed. The event wasn’t even starting today, not even fully tomorrow. The quiet after intense preparation. Snap to today. The event has now happened.

Booting 5000 Erlangs on Ampere One 192-core

Tue, 05 Aug 2025 04:00:00 +0000

From Underjord.io: In the previous post on 500 virtual linux devices on ARM64 I hinted that I expected serious improvements if we got KVM working. Well. We’re there. Let’s see what we got going on. Disclosure: I am running a conference called Goatmire Elixir which Ampere is a sponsor of. This post is not part of the sponsorship exchange as such. It is prep for my talk for the conference which uses the hardware they lent me.

500 virtual Linux devices on ARM 64

Wed, 30 Jul 2025 04:00:00 +0000

From Underjord.io: This is the first part of an experimental journey as I explore how many instances of my favorite IoT framework I can run on the 192 core Ampere One. Background I work on the Nerves project which is an IoT framework providing best-practice underpinnings and support so that you can build your IoT hubs, smart thermostats and the like with a safe and productive high-level language on a runtime known for reliability, resilience and consistent performance.

Delta support - A tale of two firmware versions

Mon, 07 Jul 2025 04:00:00 +0000

From Underjord.io: Binary deltas of firmware via fwup has been a supported feature for a while. There has also been a kind of rudimentary support for it in NervesHub. We can now remove the word rudimentary. There is now proper delta support in NervesHub. It is not in a tagged release quite yet but NervesCloud runs off of main and so can you if you would benefit from this. (I initially wrote this up for the Nerves Newsletter but wanted it shareable in some other way)

Making of an Elixir conference

Fri, 04 Jul 2025 04:00:00 +0000

From Underjord.io: It all started when I visited Gig City Elixir. Or maybe it started when I did a workshop in preparation for a Code BEAM in Stockholm. But that actually started from reading Priya Parker’s book The Art of Gathering. Maybe this has been coming for a while. I’m making an Elixir conference and it happens 10-12th of September in Varberg, Sweden. Tickets are still available at the time of writing. I figured it might be interesting to hear one data point of pulling something like this together.

How to work with XML documents in Elixir using xmerl

Sun, 15 Jun 2025 17:14:00 GMT

From Angelika.me: I want to parse an XML document, find an element by id, add an attribute, and export the document back to a string.

Elixir is not owned by Big Tech

Tue, 29 Apr 2025 04:00:00 +0000

From Underjord.io: We all have varying degrees of exposure to Big Tech. Some of it seems fine, stable and can be relied on. Some of it feels like shifting sand under your feet. React seems to move a lot on whims, I don’t envy tracking that. Go seems like it might be fairly stable? With the current geo-political climate I don’t find massive corporations to be a guarantee for stability. People may be getting fired even though they chose IBM.

Keep this in mind when changing scrollbar colors

Sat, 26 Apr 2025 15:16:00 GMT

From Angelika.me: TL;DR: always choose a scrollbar thumb color that makes it visible both against the container background and the scrollbar track.

The implications of Astro's HTML streaming

Sun, 16 Mar 2025 14:17:00 GMT

From Angelika.me: Read this if you care about accurate HTTP response status codes.

Code BEAM America 2025

Tue, 11 Mar 2025 01:00:00 -04

From Mitchell Hanberg's Blog: My first conference of 2025 was [Code BEAM America](https://codebeamamerica.com) and I had the honor of attending with a great crew from DraftKings ([we're hiring!](https://careers.draftkings.com/jobs/jr10888/lead-software-engineer-elixir/)) and to give my second ever conference talk! ## On the Elixir community Reflecting on this year's conference, I realized how comfortable I was the entire time. After 7 years in the Elixir community, I've accumulated a number for friends and acquaintences, something I really never expected from a work adjacent interest like a programming language. At my first Elixir conference, [Lonestar Elixir 2020](https://web.archive.org/web/20200308234856/https://lonestarelixir.com/) (rough year, but also the year I "went pro" with Elixir), I had a couple of acquaintences from my new job at [Bleacher Report](https://bleacherreport.com/), but I hadn't really me them yet. I'm a pretty social guy, but traveling across the country to hang out with a bunch of strangers isn't really my comfort zone. Luckily, I met folks like [Todd Resudek](https://supersimple.org/) who go out of their way to be friendly and introduce you to people they know. I've tried to embody this spirit myself at social gatherings ever since, and Code BEAM America 2025 was no exception. ## My talk This year I gave an update on our progress with the [unified language server project](/ive-joined-the-official-elixir-lsp-team/). We are a little more than 6 months into the project and it felt great to finally share how it's going and what to expect. I spoke to a number of folks on what they're excited about with the project and had a blast exploring the possibilities of the next generation of Elixir tooling. I'll update this with a link to the talk once it's available. ## The talks I thoroughly enjoyed the talks I attended this year (I can admit I do enjoy the hallway track as well...) with a couple of notable talks. ### Jason Axelson - Choosing an effective testing structure [Jason Axelson](https://www.linkedin.com/in/jasonaxelson/) gave a presentation on testing practices from which I almost broke neck from aggressively nodding the entire time. One of his suggestions I believe is the most powerful: "Make your tests async" (paraphrased, I didn't write it down because of the aforementioned head banging). The rationale is basically that by making your tests async, you are forced to iron out a lot of the concurrency kinks in your programs and it helps you really understand your codebase from the bottom up. Improving your own understanding of your codebases will pay dividends when it comes time to handle the unfortunate production incident or training juniors/new teammates. Later on, I shared with Jason an [example repository](https://github.com/mhanberg/sandrabbit) I had made which demonstrates how to structure a Phoenix application that deals with singleton GenServers (global state) and still maintain async tests. PS: Isn't it cool that at a conference you can watch a presentation and then later eat lunch (or drink beer) next to them and discuss it?? ### Jeffrey Matthias and Aidan Obley - Crafting Fully Custom Code Generators In this talk, [Jeffrey](https://www.linkedin.com/in/jeffreymatthias/) and [Aidan](https://www.linkedin.com/in/adobley/) cover how they use custom generators at [Mechanical Orchard](https://www.mechanical-orchard.com/) to help rebuild legacy programs in Elixir. In their talk, Jeffrey notes (paraphrased) "Remember, this is _your_ app, you can name the folders what you want and place the files where you'd like". I think this is an important thing to realize. I love that our community and frameworks have conventions, but sometimes I feel that folks become blinded to what they're "allowed" to do. The default Phoenix generators might have a certain naming scheme or directory structure, but that doesn't mean it's the ordained way to structure your program (it's mostly superficial anyway.) ## See ya next time I had a blast and I hope to catch ya at the next Code BEAM 👋

How to set up unit tests for Astro components

Sat, 01 Feb 2025 11:12:00 GMT

From Angelika.me: Improve your Astro unit testing experience by adding happy-dom and DOM Testing Library to your setup.

The Elixir Shirt

Fri, 13 Dec 2024 04:00:00 +0000

From Underjord.io: I wanted there to be an Elixir shirt you could buy. I talked to some people. Made some calculations. Took some debatable photos. And now you can pre-order The Elixir Shirt. The Officialness This is an officially approved use of the Elixir logo trademark, by explicit permission from the Elixir core team. Usually the trademark can’t be used commercially. I was granted permission to make and sell products with the brand.

From big Kubers down to small GenServers

Fri, 06 Dec 2024 04:00:00 +0000

From Underjord.io: Me and the team had a meeting which we dedicated to talking about architecture. Sort of an ad-hoc exploration of patterns and concepts. How systems usually fit together. Which is mostly through various types of queues. And a bunch of common patterns like request/response, publish/subscribe and workers on a queue. And most request/response is essentially workers on a queue going in two directions. This post was originally written as part of my newsletter which is a weekly thing that I’ve done for probably 5 years now.

How to clamp the lightness of a relative color in CSS

Sun, 01 Dec 2024 17:55:00 GMT

From Angelika.me: Let's say we have a color in a CSS variable and want to modify its lightness, but only if it's too dark or too light.

Voice Activity Detection in Elixir and Membrane

Wed, 27 Nov 2024 04:00:00 +0000

From Underjord.io: I hacked on something quite useful in the last few weeks, off and on. Voice Activity Detection in Elixir with Silero VAD through ONNX. I’ll show what I did and try to give an idea of what it is and why it is useful. It boiled down to this gist as a proof of concept. Should work on most Elixir installs. These days Membrane will even try to pull pre-compiled dependencies for the libraries it wants.

Bodging GenServers Together

Fri, 22 Nov 2024 04:00:00 +0000

From Underjord.io: What feels like forever ago but what was probably a year and a half I gave a talk about Lively LiveView with Membrane. Video is available for the curious. It was a stunt talk but also a talk about creativity and how Elixir let’s me plug things together and try things that feel magical. That feeling has never left me. Some of the magic is a goddamn pain. Take the Membrane framework.

How I use Erlang Hot Code Updates

Tue, 19 Nov 2024 04:00:00 +0000

From Underjord.io: One of the Erlang ecosystem’s spiciest nerd snipes are hot code updates. Because it can do it. In ways that almost no other runtime can. I use Elixir which builds on Erlang and has the same capabilities. The standard way of doing Elixir releases via mix release does not support Erlang hot code updates. As in, it will not generate the necessary files for you. And if you do want to do it there are several blog posts you need to stitch together or you need to use the Erlang docs in great detail.

Dependencies vs. devDependencies for JavaScript apps

Mon, 11 Nov 2024 19:15:00 GMT

From Angelika.me: Whenever I'm adding a new dependency to a JavaScript app, or setting up the build process of a new app, I ask myself: what exactly are devDependencies? It's time to answer that question in depth.

A Brief History of LLMs

Mon, 07 Oct 2024 15:05:50 GMT

Anatomy of Embedded Elixir

Mon, 07 Oct 2024 04:00:00 +0000

From Underjord.io: Working on the Nerves project, the Embedded framework for Elixir, has given me an increased appreciation for how Frank Hunleth and his collaborators through the years have structured things. And while I’ve found crossing into the Linux-heavy part of it difficult and frustrating there has been reasonable steps to take all the way from building the application layer in Elixir all the way back to fighting the bootloader. I’ll try to detail how a Nerves system is built up in this post.

Putting code on a Nerves device

Mon, 16 Sep 2024 04:00:00 +0000

From Underjord.io: The Nerves project is a way of building embedded Linux devices where the BEAM virtual machine takes care of running things. This does not constrain what you can run in any significant way. The easiest way to think of it is as a replacement for systemd. Though it is not only that. I will attempt to explain the different ways you can run things via the BEAM and consequently, on Nerves.

To Nerves from Elixir

Fri, 30 Aug 2024 04:00:00 +0000

From Underjord.io: I adore Nerves. I recently joined the core team. And I’ll be doing my best to help people get along with this lovely way to co-mingle hardware and massively concurrent reliable software. Getting started Assuming you have a comfortable Elixir & Erlang installed, preferrably the most recent. Most conveniently through asdf/mise, but I don’t judge. Instructions are lifted from the official docs but I will try to keep it leaner as I assume you are comfortable with Elixir.

Catching up with Elixir

Wed, 28 Aug 2024 04:00:00 +0000

From Underjord.io: I’ve kept very busy recently and as I look at what I published last it has clearly kept me from blogging. I don’t love that. I like having a blog and I like tending to it. I’ve not missed a beat on the newsletter’s weekly cadence but that might not be your jam. Let’s catch up. I’ve been diving into embedded Linux with Elixir. My latest non-newsletter issue was about The Future Stack.

I've Joined the Official Elixir LSP Team

Wed, 21 Aug 2024 01:00:00 -04

From Mitchell Hanberg's Blog: I've joined the official Elixir language server team! This is the culmination of the efforts from [Jonatan Kłosko](https://github.com/jonatanklosko) (of LiveBook), [Steve Cohen](https://github.com/scohen) (of Lexical), [Łukasz Samson](https://github.com/lukaszsamson) (of ElixirLS), and myself ([Mitchell Hanberg](https://github.com/mhanberg) of Next LS). You can read more about it on [elixir-lang.org](https://elixir-lang.org/blog/2024/08/15/welcome-elixir-language-server-team/). We are currently working on merging the three projects (Lexical, ElixirLS, and Next LS) into a single official project, so in the mean time, you can continue to use the language server you are currently using. If you would like to support my efforts on this project, please sponsor me on GitHub! I have a goal of reaching 100 sponsors, and as of writing I'm a little more than halfway there. **Sponsor link:** https://github.com/sponsors/mhanberg If you sponsor and would like an elixir-tools sticker, please email me your name and address and I'll send one your way (even internationally!)

How to add CSS rules only in the test env in your Phoenix app

Mon, 12 Aug 2024 15:29:00 GMT

From Angelika.me: Certain CSS styles might cause problems in your browser-based tests, so you might want to add some CSS rules that turn off those styles, but only in the test environment.

Rewriting a Vue app to Astro

Sun, 04 Aug 2024 08:54:00 GMT

From Angelika.me: I rewrote my hobby project to Astro and its JavaScript bundle size shrank 3x.

Newsletter issue, adept adoption

Fri, 19 Jul 2024 04:00:00 +0000

From Underjord.io: My newsletter-provider Campaign Monitor (not a recommendation, they are .. fine I guess) are having an outage. And I’ve been on an unbroken publishing streak for the newsletter for a significant number of years. Probably 4, I could check but can’t log into Campaign Monitor. So this goes on the website until I can send it properly. Dangit. Building up the Nerve(s) As we are doing NervesCloud we are thinking a lot about adoption for Nerves.

Validate and Transform Your Data with Schematic

Fri, 12 Jul 2024 01:00:00 -04

From Mitchell Hanberg's Blog: I've recently seen talk of similar libraries to [Schematic](https://github.com/mhanberg/schematic) so I figured I'd share my take on the problem space! ## Schematic Schematic is a library for validating and transforming data in Elixir, similar to [Ecto Changesets](https://hexdocs.pm/ecto/3.11.2/Ecto.Changeset.html#field_missing?/2?utm_source=thinkingelixir&utm_medium=shownotes) and [Norm](https://github.com/elixir-toniq/norm). I created Schematic early in 2023 while developing the [GenLSP](https://github.com/elixir-tools/gen_lsp) library, which I developed to build [Next LS](https://www.elixir-tools.dev/docs/next-ls/quickstart/). I needed to be able to consume and produce data structures described by the Language Server Protocol JSON Schema specification, which describes data in terms of basic scalar types and certain compound types, similar to some algebraic data types. I wanted a library that lends itself to expressibility, composition, and code generation. ## Basic schematics Schematic provides... _schematics_ for basic primitive types in Elixir. ```elixir import Schematic unify(int(), 1) #=> {:ok, 1} unify(int(), "one") #=> {:error, "expected an integer"} ``` These are just functions, so you can bind them to variables and return them from functions. ```elixir defmodule Numbers do import Schematic def integer(), do: int() def validate(value), do: unify(integer(), value) end Numbers.validate(1) #=> {:ok, 1} Numbers.validate("one") #=> {:error, "expected an integer"} ``` ## List and Tuple schematics We can also define schematics for lists and tuples. ```elixir defmodule Hobbies do import Schematic def validate(values), do: unify(list(str()), values) end Hobbies.validate(["foosball", "cooking"]) #=> {:ok, ["foosball", "cooking"]} Hobbies.validate([1, "cooking"]) #=> {:error, [error: "expected a string", ok: "cooking"]} Hobbies.validate("foosball") #=> {:error, "expected a list"} ``` ## Map and Struct schematics Map and struct (or `schema` in Schematic parlance) schematics are versatile and extendable. ```elixir defmodule Animals do import Schematic def schematic() do map(%{ species: str(), genus: str(), color: str() }) end defmodule Cat do def schematic() do map(Animals.schematic(), %{ breed: str(), declawed: bool() }) end end end Schematic.unify(Animals.schematic(), %{}) #=> {:error, # %{ # color: "expected a string", # species: "expected a string", # genus: "expected a string" # }} Schematic.unify(Animals.schematic(), %{color: "black"}) #=> {:error, %{species: "expected a string", genus: "expected a string"}} Schematic.unify(Animals.schematic(), %{color: "black", species: "lupus", genus: "canis"}) #=> {:ok, %{color: "black", species: "lupus", genus: "canis"}} Schematic.unify(Animals.Cat.schematic(), %{color: "orange", species: "catus", genus: "felis"}) #=> {:error, %{breed: "expected a string", declawed: "expected a boolean"}} Schematic.unify(Animals.Cat.schematic(), %{ color: "orange", species: "catus", genus: "felis", breed: "shorthair", declawed: false }) #=> {:ok, # %{ # color: "orange", # species: "catus", # genus: "felis", # breed: "shorthair", # declawed: false # }} ``` Structs can be created from plain maps using the `schema` schematic. By default it looks for string keys and converts them to atom keys, but that can be disabled using the `convert: false` option. ```elixir defmodule Animals do import Schematic defstruct [:species, :genus, :color] def schematic() do schema(__MODULE__, %{ species: str(), genus: str(), color: str() }) end end Schematic.unify(Animals.schematic(), %{"species" => "lupus", "genus" => "canis", "color" => "grey"}) #=> {:ok, %Animals{species: "lupus", genus: "canis", color: "grey"}} ``` ### Optional keys and nullable fields Optional keys and nullable values can be specified using the `optional` and `nullable` schematics. Combining this with a struct, you can create default values for certain keys. `optional` keys do not have to be present, but if they are, the value must unify with the given schematic. ```elixir defmodule Animals do import Schematic defstruct [:species, :genus, color: "brown"] def schematic() do schema(__MODULE__, %{ optional(:color) => str(), species: str(), genus: nullable(str()) }) end end Schematic.unify(Animals.schematic(), %{ "species" => "lupus", "genus" => nil, }) #=> {:ok, %Animals{species: "lupus", genus: nil, color: "brown"}} ``` ### Tranforming keys While `schema` will automatically convert string to atom keys, you can also use a tuple for the key specification for key transformation like camelCase to snake_case. ```elixir defmodule JobPosting do import Schematic def schematic() do map(%{ {"startDate", :start_date} => str(), optional({"salaryRange", :salary_range}) => str(), {"title", :title} => str() }) end end Schematic.unify(JobPosting.schematic(), %{ "startDate" => "Jan 1, 2025", "title" => "Chicken Tender Engineer" }) #=> {:ok, %{title: "Chicken Tender Engineer", start_date: "Jan 1, 2025"}} ``` You can also use the `dump` function to transform keys in reverse. ```elixir Schematic.dump(JobPosting.schematic(), %{ title: "Chicken Tender Engineer", start_date: "Jan 1, 2025" }) #=> {:ok, %{"startDate" => "Jan 1, 2025", "title" => "Chicken Tender Engineer"}} ``` ## Advanced schematics Most of your data is rather complex and can be specified further than just a "string", you might have an enumeration, you might actually say a value can be either a `Mammal` or a `Reptile`, or convert an ISO timestamp into an Elixir DateTime struct. ### `oneof` If you want to say a value is "one of" a list of schematics, you can use the `oneof` schematic. I believe the semantics are similar to an enum or union type from other languages. In this example, we also demonstrate using literals as schematics. ```elixir defmodule HousePet do import Schematic def schematic() do map(%{ name: str(), type: oneof([ "Dog", "Cat", "Hamster", "Fish" ]) }) end end ``` Making an enum of strings is nice, but for a proper union type style schematic, we can use other schematics, even map schematics. ```elixir defmodule HousePet do import Schematic def dog, do: map(%{type: "dog"}) def cat, do: map(%{type: "cat"}) def hamster, do: map(%{type: "hamster"}) def fish, do: map(%{type: "fish"}) def schematic() do oneof([ dog(), cat(), hamster(), fish() ]) end end Schematic.unify(HousePet.schematic(), %{type: "cat"}) #=> {:ok, %{type: "cat"}} ``` Unfortunately the error message for these kind of failure case is not very good, but will be improved in a future version Schematic. ```elixir Schematic.unify(HousePet.schematic(), %{type: "snake"}) #=> {:error, "expected either a map, a map, a map, or a map"} ``` ## Value based validations So far we've covered more _structural_ style of data validation, but we can also do more value based validations that you are probably used to in your `Ecto.Changeset` code. We can use the `all` and `raw` schematics to accomplish this! ```elixir defmodule SpecialNumber do def schematic do all([ int(), raw(&Kernel.<(&1, 10), message: "must be less than 10"), raw(&(Kernel.rem(&1, 2) == 0), message: "must be divisible by 2") ]) end end Schematic.unify(SpecialNumber.schematic(), 8) #=> {:ok, 8} Schematic.unify(SpecialNumber.schematic(), 15) #=> {:error, ["must be less than 10", "must be divisible by 2"]} Schematic.unify(SpecialNumber.schematic(), "15") #=> {:error, ["expected an integer", "must be less than 10", "is invalid"]} ``` ## Transforming Data You can also use the `raw` schematic to transform the data as you parse and validate it. Here we read a ISO8601 timestamp and turn it into a `DateTime` struct. ```elixir defmodule Datetime do import Schematic def schematic() do raw( fn i, :to -> is_binary(i) and match?({:ok, _, _}, DateTime.from_iso8601(i)) i, :from -> match?(%DateTime{}, i) end, transform: fn i, :to -> {:ok, dt, _} = DateTime.from_iso8601(i) dt i, :from -> DateTime.to_iso8601(i) end ) end end Schematic.unify(Datetime.schematic(), "2024-07-11T17:48:41.972851Z") #=> {:ok, ~U[2024-07-11 17:48:41.972851Z]} ``` ## Dumping Data Not only can you parse and validate external data into your internal format, you can also _dump_ that data back into the external format. This will respect any map key transformations that you've declared and as seen above, you can use a `raw` schematic to arbitrarily control how the data is transformed in each direction. ```elixir Schematic.dump(Datetime.schematic(), ~U[2024-07-11 17:48:41.972851Z]) #=> {:ok, "2024-07-11T17:48:41.972851Z"} Schematic.dump(Animals.schematic(), %Animals{ species: "lupus", genus: "canis", color: "grey" }) #=> {:ok, %{"color" => "grey", "genus" => "canis", "species" => "lupus"}} ``` ## Future features While the `oneof` schematic handles "union" types (typically represented like `Dog | Cat`), I would like to add "intersection" types (represented sometimes like `Dog & Cat`). ## Conclusion I am pretty happy with what I've come up with, and it works for my use cases very well! You can see Schematic in action in the [gen_lsp](https://github.com/elixir-tools/gen_lsp/blob/main/lib/gen_lsp/protocol/requests/initialize.ex) code base and for an example of how it works with code generation you can check out the [lsp_codegen](https://github.com/elixir-tools/lsp_codegen) project. Happy hacking!

Pet Peeves

Wed, 19 Jun 2024 01:00:00 -04

From Mitchell Hanberg's Blog: > **noun** _informal_ > > **something that a particular person finds especially annoying:** _one of my biggest pet peeves is poor customer service._ Here's a list of minor things I find irritating. I'll attempt to keep this page updated as more irritating things inevitably cross my path. - Calling software "dead" or "abandoned" - Complaining about too many choices, especially when C=2 - Complaining about what other people are doing when it doesn't affect you at all - Judgement without context - Speaking in a way that implies you have a ton of experience with something (saying "I do this in all my apps") when really you've done it two times - The word "just"

Automated accessibility testing for Elixir web applications

Mon, 10 Jun 2024 04:15:00 GMT

From Angelika.me: Integrate Axe into your Elixir browser tests with my new library, A11yAudit.

Create Your Own Neovim Distribution

Wed, 05 Jun 2024 01:00:00 -04

From Mitchell Hanberg's Blog: Gotcha! The click bait worked! We're not really in the market to create an actual "distribution", but we are going to explore how to extract your Neovim configuration into it's own plugin. Other real distributions actually employ this trick themselves like [LazyVim](https://github.com/LazyVim/LazyVim) and [AstroVim](https://github.com/astronvim/astronvim), the main requirement is that you use the [lazy.nvim](https://github.com/folke/lazy.nvim) package manager. Let's get into the code! ## Converting your current configuration Converting your configuration into a plugin is mostly just renaming some files/directories and moving them into their own repo. ### Original Configuration Your original configuration might look something like this, you have a folder that handles your lazy.nvim plugin specs, some custom modules, some ftplugins, and a normal `init.lua`. ``` $HOME/.config/nvim/ └── lua/ ├── custom/ │ ├── plugins/ │ │ ├── init.lua │ │ ├── elixir.lua │ │ └── lsp.lua │ ├── terminal.lua │ └── treesitter.lua ├── ftplugin/ │ ├── elixir.lua │ └── javascript.lua └── init.lua ``` ### Plugin based Configuration The steps I took to extract my distribution was to: - move the whole thing to a new git repository. - rename `custom` to `mydistro` and resolve any necessary changes. - rename `init.lua` to `plugin/mydistro.lua`. Your new configuration structure should look like this: ``` $HOME/ ├── .config/nvim/ │ └── init.lua └── mydistro/ └── lua/ ├── custom/ │ ├── plugins/ │ │ ├── init.lua │ │ ├── elixir.lua │ │ └── lsp.lua │ ├── terminal.lua │ └── treesitter.lua ├── ftplugin/ │ ├── elixir.lua │ └── javascript.lua └── plugin/ └── mydistro.lua ``` ### init.lua The `init.lua` file in your dotfiles should look like this: ```lua -- bootstrap lazy.nvim local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" if not vim.uv.fs_stat(lazypath) then vim .system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", "--branch=stable", -- latest stable release lazypath, }) :wait() end vim.opt.rtp:prepend(lazypath) require("lazy").setup { spec = { { "myname/mydistro", -- the location on GitHub for our distro dev = true, -- tells lazy.nvim to actually load a local copy import = "mydistro.plugins" -- the path to your plugins lazy plugin spec }, }, dev = { path = "~" }, -- the path to where `dev = true` looks for local plugins install = { missing = true, }, } ``` And we're done! ## Why? Well, one: for fun! And two: I personally use [home-manager](https://github.com/nix-community/home-manager) to manage my dotfiles, but that requires running home-manager anytime you change them. This is very annoying when it comes to tweaking your Neovim configuration, so moving my configuration to a plugin that lives outside of home-manager means I can iterate quicker. Another hypothetical use case is making it easier for someone to try out your Neovim configuration. This could be for someone getting into Neovim for the first time, or perhaps a plugin author trying to help debug an issue you're having. Happy hacking!

The Future Stack

Tue, 28 May 2024 04:00:00 +0000

From Underjord.io: Fly.io is a highly visible cloud provider in the Elixir ecosystem and they put forward an interesting promise. They don’t deliver on that promise currently but I think it would be very compelling if they get there. Especially for Elixir. Let’s dig in. This work is sponsored and supported by Tigris. Object Storage that works like a CDN on Fly. They are also part of the subject of the post. You’ll see.

How to change your local timezone on a mac to debug date-related JavaScript tests

Sat, 25 May 2024 14:09:00 GMT

From Angelika.me: My date-related JavaScript tests were passing locally, but failing on CI. Changing my local timezone helped me find the bugs.

Chatting, Sharing (& Shots) in Chattanooga - GigCity 2024 report

Thu, 23 May 2024 04:00:00 +0000

From Underjord.io: I went to Chattanooga in Tennessee from Sweden to hang out with the Elixir community. I’ve been part of Elixir in various ways for 6-7 years now and this is the first time things have lined up and I could go to the US for a conference: I had a sponsor for the trip. I was offered to not just speak but keynote. The conference is put on by friends, Bruce and Maggie Tate, who’ve supported a lot of great stuff in the Elixir community for a long time.

Unpacking Elixir - IoT & Embedded with Nerves

Fri, 26 Apr 2024 04:00:00 +0000

From Underjord.io: In this part of the series we dive into one of the frameworks and toolsets that really got me going with both Elixir as a hobby and the community as a space full of helpful people. This will be all about The Nerves Project, oh, and touch on some related stuff. Before we dig in I should shout out some other BEAM, Elixir & Erlang-related things in the embedded space. AtomVM seems super cool and lets you do Erlang and Elixir on microcontrollers.

9 signs your frontend code has quality issues that affect your users

Sat, 13 Apr 2024 16:47:00 GMT

From Angelika.me: Check if your project is displaying any of them.

How to prevent WebStorm from removing trailing spaces from one specific file?

Fri, 29 Mar 2024 12:32:00 GMT

From Angelika.me: I love WebStorm's "on save" formatting options, but from time to time, they get in my way.

Fundamentals of Object Storage

Tue, 19 Mar 2024 04:00:00 +0000

From Underjord.io: I did a livestream where I talked about Object Storage. The how and the why. The Bad Old Days. And also the neat and interesting stuff just beyond the basics. I figured I’d cover that in text as well. You can watch the stream here. Transparency notice: The livestream and this blog post have been work supported by Tigris. We collaborate on the topics, they provide resources and pay for some of my time so I can do this stuff instead of writing software for clients.

Modern Format on Save in Neovim

Thu, 14 Mar 2024 08:00:00 -05

From Mitchell Hanberg's Blog: Formatting on save is a popular workflow and is builtin to many text editors and IDEs. In Neovim, you must create this manually, but it is very easy using `autocmds`. ```lua -- 1 vim.api.nvim_create_autocmd("LspAttach", { group = vim.api.nvim_create_augroup("lsp", { clear = true }), callback = function(args) -- 2 vim.api.nvim_create_autocmd("BufWritePre", { -- 3 buffer = args.buf, callback = function() -- 4 + 5 vim.lsp.buf.format {async = false, id = args.data.client_id } end, }) end }) ``` 1. We create a new `autocmd` that fires on the `LspAttach` event. This event is fired when an LSP client attaches to a buffer. In this `autocmd`, you can easily set configuration that is specific to that buffer and LSP client. 2. We create another `autcmd` inside the `LspAttach` callback, this time for the `BufWritePre` event. This fires when you save the buffer but before it flushes anything to disk. This gives you a chance to manipulate the buffer first. 3. We configure this `autocmd` to only execute for the current buffer. This is a little more straight forward rather than setting an `autocmd` that executes for any range of file types. 4. In the callback, we run `vim.lsp.buf.format` to format the buffer, with the flag `async = false`. This ensures that the formatting request will block until it completes, so that it completely finishes formatting before flushing the file to disk. 5. We also set the `id = args.data.client` flag so that the formatting request is only sent to the LSP client that is related to the outer `LspAttach` request. This ensures that we aren't running the formatting request multiple times in case the buffer is attached to multiple LSPs. And there we have it, modern format on save for those who want it.

A great music system

Fri, 08 Mar 2024 09:00:00 +0100

From Posts on Claudio Ortolina:

Over the last few months I had the opportunity to spend some time ironing out a music system that would marry analog and digital listening, log everything I play for recommendations and tracking of future releases, and collect all physical releases I own along with accompanying notes and reflections.

Music library

I own music in different formats:

Vinyl records
CDs
High-resolution files (usually in FLAC format)

Why 3 formats?

Vinyl is usually the best format for old records before the 1980s, as it was the dominant medium. For a lot of music, there’s literally no other available physical format. The format had a massive revival in the last few years, and many artists release high-quality, 180g vinyls which sound amazing.
CDs tend to be the target format for music produced in the late 1980s up to the 2010s, before streaming took off. A FLAC digital file is absolutely fine as a replacement for a CD quality-wise, but I’m a sucker for booklets and limited edition goodies. Particularly in the UK, second-hand CDs are sold in pretty much any charity shop, and more often than not you can get very good deals.
Digital files are convenient for listening on the go, and are also sometimes the only option for bands who don’t produce physical releases. Both record labels and websites like Bandcamp give the option to purchase in FLAC format.

What’s crucial here is that for music I really love, I do wanna own it for a few reasons:

For new releases, I want to compensate the artist or band, and the best way is to buy their music (and attend their gigs).
Streaming platforms can pull content anytime, and in many cases they don’t have all releases I want to listen to.
Once I have albums in my library, I can organise them how I prefer (both physically and digitally).

A priceless extra is that my 2-year old daughter loves CDs because they look like little books but they make music, and vinyls because they’re big and rotate.

Hardware

There are a few moving parts:

A Synology NAS storing all digital files.
A Ruark R5 music system (which can play CDs directly, and that has an integrated amplifier for the turntable). It’s been recently discontinued, which does make a bit uneasy, but the manufacturer still supports it and I reckon I can go on for a few years before having to evaluate a replacement.
A Pro-Ject E1 turntable, playing through the R5. Pricy, but it really just works.
A Raspberry Pi 4 with a HifiBerry DAC2 Pro hat, which allows the PI to play audio with great quality via the R5.

None of this is cheap and there’s certainly more affordable options particularly if you’re able to source a different speakers/amp/turntable combo. The big advantage of using a Raspberry Pi (or an equivalent off the shelf solution) is that you separate “brain” from “muscle” (and the Pi + DAC hat are relatively cost-effective).

Playing music

The whole system revolves around Plex: the NAS runs Plex Media Server, while the Raspberry Pi runs PlexAmp headless. My laptop and phone run PlexAmp as well.

Setting up PlexAmp headless on the Pi required minimal work thanks to the excellent bash-plexamp-installer project, which makes it a breeze to both install and update the software and correctly configure the DAC2 Pro hat. Couple of reboots and everything worked like a charm (and still does).

With this setup, I can use any device to access my music collection, and play it through the Pi if I’m at home, or on-device if I’m out.

The Plex Media Server instance is configured to scrobble to Last.fm, so everything gets logged automatically no matter where I play it from.

When I play physical releases, I use the excellent OpenScrobbler.com web application to search for the album I’m playing, and scrobble it.

I’m now trying out Tidal as a way to listen before buying, as it provides hi-fi quality, pays artists better than other platforms, and it’s deeply integrated into Plex (which means I don’t need to use a separate app, and can rely just on PlexAmp).

If the Tidal experiment is a success, I’ll stop my subscription to Apple Music.

When music is played by the Pi, the R5 system has no information on what’s currently playing. I can read that on my phone, but for other people in the house I programmed a small automation that can be run with Siri, so that anyone can ask “What’s playing?” and get a good answer. This took some lightweight reverse engineering of the PlexAmp web application, and I’m not expecting it to be rock solid as it’s based on private APIs.

In short, the PlexAmp web application polls an endpoint that returns a fairly comprehensive playing status with metadata information about the artist being played, both for local music in the Plex Server and on Tidal. As PlexAmp is written in Node.js, I wrote another small Node.js application to poll the same endpoint, and parse the information I need. I then created an iOS shortcut to hit my Node.js application, and read out the response in a human readable format. The shortcut is automatically available on all devices, and can be run via Siri by its name.

Discovery

Algorithmic recommendations are now very precise - no matter the platform. I’ve come to find them too precise in the sense that they don’t stray off the beaten path.

I prefer to monitor different sources, particularly when it comes to my core preference, progressive rock:

Prog Magazine, which is an old-school monthly zine (both printed and digital) that covers pretty much anything happening in the progressive scene. I have a digital subscription, and read it on the iPad where I can take notes and add albums to a queue.
The reviews RSS feed for progarchives.com, which is a fairly old progressive rock community website where people publish reviews of whatever album they can think of. The RSS format is great because I can read the review, see the cover art (which does a lot for me), and from that decide if I’m interested to explore more.
The occasional visit to a few subreddits, just to get a feel of the community is looking at.
Newsletters from specific record labels that tend to publish music I like (e.g. Kscope) or Karisma Records)
The Album Years podcast with Steven Wilson and Tim Bowness, which provides a very opinionated list of significant music releases roughly from the 70s till the 90s. Only downside is that it’s very UK-centric, and I wish there were similar lists for other parts of the world.

Once I’ve listened to something, and the artist is scrobbled to Last.fm, I’m able to monitor new releases via the excellent MusicHarbor iOS app. The app imports the list of artists I have on Last.fm, and keeps track of all releases by these artists. The import process is easily done manually via a few button presses in the app, and I do that once a month.

Each Friday (release day!) I get a new batch of albums to check out, and I add whatever picks my attention to my queue.

Physical collection management and notes

Managing a physical collection is a relatively solved problem: with Discogs, one can simply scan or search for the correct release, and add it to their own account.

While this is great to track value and conditions of the item, it’s not geared towards managing a collection with associated notes about the artist(s), or lyrics. It’s also not possible to arbitrarily draw connections between albums.

I’m currently trying out Obsidian with the MediaDB plugin. This lets me quickly add every album via the MusicBrainz search API (without matching to an exact release, i.e. you can’t pick the correct year/label/country/limited edition).

Each album becomes its own file with a set of metadata information I can query through a couple of plugins. On top of that, I can write notes and associate albums with simple internal links.

As the data is stored as markdown files with a YAML front matter, there’s no risk of lock-in, and if I ever need to process the data for further analysis or visualization, I can write my own program that does that.

Obsidian is available on all platforms I use, and syncs both data and settings without having to do anything special.

Too much?

I often ask myself if this system is too complicated, but I personally find that the experience of using it is simple at the expense of a reasonable amount of hidden complexity. I’m also aware that my requirements are many, and that’s because music is pretty much my only significant hobby. It still gives me the same joy I felt as a teenager, and still manages to surprise me even when I think I heard it all.

Challenges of local-first LLMs

Fri, 08 Mar 2024 04:00:00 +0000

From Underjord.io: TLDR: the tricky part is “Large”. “Language” and “Model” seems manageable. But largeness has all sorts of trouble associated with it for mobile devices. Not insurmountable, but challenging. Also makes for finicky development. To start off, I am not an AI expert. I am not an ML engineer. I’m a web and systems dev that mostly works in Elixir these days. Through the Elixir community I got connected with ElectricSQL and have done some collaboration with them.

How to format Elixir doctests?

Sat, 02 Mar 2024 14:33:00 GMT

From Angelika.me: I wrote a doctest formatter plugin to help you with that.

How to format Elixir code in Markdown code blocks?

Sat, 27 Jan 2024 15:03:00 GMT

From Angelika.me: I wrote a Markdown code block formatter plugin to help you with that.

Unpacking Elixir: Phoenix

Mon, 22 Jan 2024 04:00:00 +0000

From Underjord.io: In this series I’ve been unpacking various facets of Elixir. Mostly this has meant trying to explain Erlang and the BEAM through the lens of Elixir. Now we are moving into the domain of the web framework. This is where I dare say that Elixir has much more to say than Erlang. Erlang has to my understanding never landed fully on a canonical preferred web framework. Elixir has Phoenix and this post will be unpacking Phoenix.

Do not run `mix test || mix test --failed`

Mon, 08 Jan 2024 19:46:00 +0100

From Angelika.me: This popular way of retrying flaky tests on CI is a trap.

Unpacking Elixir: The Actor Model

Thu, 16 Nov 2023 04:00:00 +0000

From Underjord.io: This series covers a lot of fundamentals about the underlying BEAM VM and Erlang as consequence of covering Elixir fundamentals. A lot has been said about The Actor Model when it comes to Erlang. That’s kind of funny. Because the only thing that as a matter of terminology should definitely be called actors in the Erlang world are Bjarne Däcker, Joe Armstrong, Mike Williams and Robert Virding as featured in Erlang: The Movie.

Ergonomic Remote Development

Tue, 07 Nov 2023 08:00:00 EST

From Mitchell Hanberg's Blog:

I recently built a new PC (you can see the specs on my /uses page!) and installed Linux on it.

The way I have been using it mostly has been through an SSH connection, even though its sitting underneath my desk, plugged into my monitor, and all my peripherals plugged into a nifty USB hub splitter thing!

I simply couldn't live without the macOS desktop environment. I have so much muscle memory for all the shortcuts and have so many apps that I use that enhance my workflow.

I have never remotely developed for this long before, so I quickly ran into a bunch of paper cuts for which I was able to easily find bandaids.

Tailscale

When you are going to be SSHing into a remote computer, you need to know the IP address of the computer.

Tailscale makes this super easy. You install Tailscale on your local computer and on the remote computer, and they both join your "tailnet".

Now, you have a static IP address that only other computers on your tailnet can access!

$ ssh mitchell@<remote ip>

Welcome to Ubuntu 23.10 (GNU/Linux 6.5.0-10-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

6 updates can be applied immediately.
To see these additional updates run: apt list --upgradable

*** System restart required ***
Last login: Tue Nov  7 07:24:00 2023 from <local ip>

Clipboard

You'll want to make sure that you can still copy/paste to/from your host computer's clipboard (or 'pasteboard' as macOS calls it) from within TUI applications like Vim/Tmux and in shell scripts.

TUI Apps

If you are using a modern terminal emulator (I use Ghostty), you most likely have clipboard working already for TUI applications, as long as they support the appropriate terminal features.

I use Neovim, which does not currently support the OSC-52 terminal feature that enables system clipboard communication, but I use Neovim inside tmux, which does!

And luckily, Neovim has a tmux 'clipboard provider' which is how Neovim actually communicates to the "outside" clipboard.

If you don't use tmux and use Vim/Neovim, there are plenty of plugins that implement it!

Scripting

The way that I have implemented scripting to my local clipboard is to again use SSH!

Since your computers are using Tailscale and are on the same tailnet, this means that your local computer also has a nice and static IP address that you can use.

Here is an example:

$ ssh mitchell@<local ip> pbpaste \
  | some-local-command \
  | ssh mitchell@<local ip> pbcopy

Here, we remotely run the pbpaste command (which, along with pbpaste, are the macOS scripting utilities for using the system clipboard), pipe the ouput into a local command, and then pipe it into ssh, which will send it to the pbcopy command on our local computer.

Now, you can easily wrap that up in an alias or a shell script.

Opening your web browser

If you are used to opening web pages with utilities like the GitHub CLI gh, you'll notice that those don't work anymore. This is because (on Linux), the tool is (most likely) running xdg-open, which is similar to the open command on macOS.

You are running this on the remote computer, which is not logged into a desktop environment, and has no web browser.

Well, we can easily fix this again with SSH!

What I did was write a shell script called xdg-open and put it in my $PATH. This way, tools like gh will actually call my script instead of the built-in xdg-open.

My script looks like this:

#!/usr/bin/env bash

function main() {
	local ip
	local uri

	uri="$1"
	if [[ ! -z "$SSH_CONNECTION" ]]; then
		ip="$(echo "$SSH_CONNECTION" | awk '{ print $1 }')"

		ssh "mitchell@$ip" open "$uri"
	else
		xdg-open "$uri"
	fi
}

main "$@"

We check the $SSH_CONNECTION environment variable to see if we are in an SSH session.

If we are not, we just call xdg-open as usual. This is helpful in case we log onto our PC like a normal person.

If we are, then we parse our local IP address out of the $SSH_CONNECTION variable and run the open command remotely using ssh.

Web Development

Now, if you are a web developer, you typically will be starting a local web server and previewing your site or app in the browser. This gets a little tricky when your browser and web server are not on the same computer!

Tailscale

Luckily, tailscale comes to the rescue again!

With tailscale, you can create a reverse proxy served over https with your existing free plan.

$ tailscale serve https / http://localhost:4000

This will create a reverse proxy that is only available inside your tailnet!

If you want to show off your beautiful website to a client or coworker, you can run tailscale funnel 443 on, which will make your reverse proxy available outside of your tailnet.

SSH Port Forwarding

You can also just tack on some options to the ssh command instead of using Tailscale

$ ssh mitchell@<remote ip> -L 4999:localhost:4999

Signing Git Commits

I sign my git commits using the 1Password SSH agent. This allows me to use an SSH key (instead of a GPG key) and to authorize the usage of the key with Touch ID on my Mac.

As you can imagine, when I went commit my first code on my new PC, I thought I had found a roadblock kill this new workflow.

Luckily, you can actually forward your SSH agent when you make and SSH connection. This is typically for when you are machine hopping and have to ssh to a remote machine from inside an ssh connection, so that you don't have to install your keys on your local computer and the first remote computer.

And, this also works for 1Password Git Commit signing!

Just add an entry in your ~/.ssh/config for your PC to allow forwarding on your local computer:

Host <remote ip>
  ForwardAgent yes

And on the PC, configure the IdentityAgent to use 1Password. I don't actually remember if this is necessary, but when writing this post, I found this config and I don't remember writing it, so it must be important!

Host *
  IdentityAgent ~/.1password/agent.sock

Conclusion

And there we have it!

Now you should be able to develop remotely and not even be able to tell the difference, except for the sheer speed of your overpowered new PC!

Unpacking Elixir: Observability

Mon, 02 Oct 2023 04:00:00 +0000

From Underjord.io: Elixir supports the usual supects of observability. Open Telemetry (OTel), log handlers, capturing metrics. And it does it well. This post will mostly focus on the observability you have on the BEAM that is either incredibly rare to see elsewhere or possibly entirely unique. The previous posts on concurrency and resilience might give useful context around how processes work and how supervision trees are structured. I will try not to lean too heavily on them but if you feel the need to understand more, consider reading them.

Unpacking Elixir: Resilience

Sun, 24 Sep 2023 04:00:00 +0000

From Underjord.io: The nine nines. 99.9999999% of uptime. Whether the AXD301 actually deserves to be held up as a system of nine nines seems debatable. I am not particularly interested in that debate. Erlang has a strong record for reliability and a design intended to help you as a developer and operator achieve your nines. Maybe just five of them. Up to you really. Previous episodes of this article series has unpacked Concurrency, Real-time & Latency and the syntax.

Create a sorted Index in Ecto

Sat, 09 Sep 2023 11:45:03 GMT

From ⚡ Maqbool Khan: defmodule MyApp.Repo.Migrations.AddMessagesInsertedAtIndex do use Ecto.Migration @disable_ddl_transaction true @disable_migration_lock true def change do create index("messages", ["inserted_at DESC"], concurrently: true) end end if y...

Start async task under our application Supervision tree

Sat, 09 Sep 2023 11:31:04 GMT

From ⚡ Maqbool Khan: Inside your application.ex file we will add our task supervisor with the name MyApp.TaskSupervisor MyApp.Application is the module where we essentially describe in what order BEAM should start our elixir application and it's the place where you descr...

Unpacking Elixir: Real-time & Latency

Fri, 08 Sep 2023 04:00:00 +0000

From Underjord.io: Elixir was built on Erlang. Erlang was built to provide “consistently low latency” and a few other audacious goals. Note, this is not a hard realtime constraint. It is soft, squishy and yet, important and real. It makes Erlang unusually suitable to systems where latency matters and where a near-realtime experience is necessary. Soft realtime. This part of the Unpacking Elixir series will really benefit from having read Unpacking Elixir - Concurrency as that post covers a lot about how concurrency works in Erlang and with that it covers Processes and Schedulers.

Unpacking Elixir: Syntax

Fri, 01 Sep 2023 04:00:00 +0000

From Underjord.io: Elixir is a language with syntactical roots in Ruby. It also carries the Erlang legacy. Legacy used here as in “a great legacy” and not as in “system you don’t like anymore”. Ruby is an object-oriented language. Elixir is functional language. The Erlang part has an impact as Elixir was designed to provide strong interoperability with Erlang. Like Ruby and Erlang, Elixir offers a high-level of abstraction and is a very dynamic language.

Unpacking Elixir: Concurrency

Fri, 25 Aug 2023 04:00:00 +0000

From Underjord.io: Elixir is the thing I do most of my public writing and speaking about. It is my default programming language for the last 5-6 years. It suits my brain. Performs well for the kind of work I typically do. And using it I have experienced very few drawbacks. Rather than writing yet another post trying to widely summarize what I think is beneficial about the language I want to try and go a bit deeper on one particular aspect I like.

Arriving Somewhere

Fri, 23 Jun 2023 17:34:25 +0300

From Posts on Claudio Ortolina:

I’m almost 40 - and while my life has somehow the shape that I envisioned as I grew up, there are definitely big differences. Think about the same picture, but in different colors.

There’s music that accompanied me for the last 20 years, pretty much since I became an adult. It’s been long enough that I don’t exactly remember when it entered my life, and in some ways it feels like it’s always been there.

Of all that music, thousands of songs, there’s a handful that made a deep mark that I still carry with me. More than anything else, one song stands above any other: Arriving Somewhere, But Not Here by Porcupine Tree.

I turned 39 a few days ago and my wife got me as a gift a very nice edition of Deadwing, the album the song is included in. It’s a 2018 remaster, which I’m listening to on a high-quality system.

It’s a 12 minute song, with long instrumental sections, and I know every single little twist - yet this new version has some little extra details, some of the ambient parts are crisper, some of the guitar sounds pop a little bit more. I love it.

It also dawned on me that it is a song about how life turns out different than you think - with fairly tragic images - but with a growing sense of peace as notes go by.

There is relief in the understanding that some pieces of someone’s life are set - that some of the choices made are points of no return. That some dreams are over, and that’s ok.

I do have the feeling of having arrived somewhere, but not here. It is different, but it’s equally beautiful. And I’m finally ok with that.

And through the twists and turns of the last 20 years, I have a song that feels like an old friend that grew up with me, or even that was a little bit ahead, and I finally caught up.

To the next 20 years - hopefully I’ll get somewhere.

The many states of Elixir

Tue, 13 Jun 2023 04:00:00 +0000

From Underjord.io: We of the blessed church of Functional Programming pride ourselves on our immutability, purity and lack of noxious side-effects. We do not mutate the state. We only produce new and better state. Deterministic state. Correct state. The best state. Except that I work in Elixir. Elixir is built on Erlang. I like to think Erlang being FP is mostly an accidental side-effect of trying to solve a bunch of complex requirements around distributed systems, fault tolerance and consistently low latency (this predates the concurrency story, another kind-of-accident).

Scripting with Elixir

Mon, 12 Jun 2023 04:00:00 +0000

From Underjord.io: I was a Python developer for some time and one great joy of Python is that you have an expressive language that you can use for your serious apps as well as for your hacky little one-off script or bespoke pieces of automation. By expressive I mean that typing very little can give you a lot of progress towards your result. I’ve scripted a fair bit in Python. Now I do it with Elixir.

Why do ML on the Erlang VM?

Fri, 09 Jun 2023 04:00:00 +0000

From Underjord.io: Another question might be; why do machine learning at all? I’m not big into ML/AI though I’ve been poking it more recently as the open models, such as Stable Diffusion and the more practical Whisper, caught my curiosity. I have a very decent GPU (3090 Ti) and I’ve poked around a bit. I don’t consider ML a super exciting solution to all the problems or a harbinger of general artificial intelligence.

OTP Process Abstractions with proc_lib

Mon, 22 May 2023 01:00:00 -04

From Mitchell Hanberg's Blog: In November of 2022, I had the privilege to speak at [Code BEAM America](https://codebeamamerica.com/). You can check out the video below, let me know what you think!

ElixirConf EU 2023, Lisbon report

Thu, 27 Apr 2023 04:00:00 +0000

From Underjord.io: Last week I attended ElixirConf in Portugal and had a lovely time. I’ll try to capture my experience of the conference here in this post. For me and for you. The last ElixirConf I visited was Prague in 2019. Pre-pandemic. I had just gotten into Elixir and kind of decided that I should actually really engage and try to do the whole community thing with this language as it seemed like it had a community of a comprehendable size.

Credo Language Server and the birth of elixir-tools

Tue, 18 Apr 2023 01:00:00 -04

From Mitchell Hanberg's Blog: Last year I started working on [gen_lsp](https://github.com/mhanberg/gen_lsp), an abstraction for writing [language servers](https://microsoft.github.io/language-server-protocol/) in Elixir. > I gave a presentation on gen_lsp and writing OTP process abstractions at CodeBEAM America 2022. You can watch my talk on [YouTube](https://www.youtube.com/watch?v=Ug-SEozyG1A). Today I'd like to announce the release of the first language server built with `gen_lsp`. ## Credo Language Server [Credo Language Server](https://github.com/elixir-tools/credo-language-server) is a persistent server that communicates with text editors via the Language Server Protocol. This initial release comes with project wide diagnostics and a code action to add a `# credo:disable-for-next-line` magic comment above any Credo warning. You can install it today using one of the `elixir-tools` family of editor extensions. ## elixir-tools [elixir-tools](https://github.com/elixir-tools) is the new home for Credo Language Server and the aforementioned editor extensions. ### elixir-tools.nvim If you write Elixir and use [Neovim](https://neovim.io), there is a chance you are already using my plugin, [elixir-tools.nvim](https://github.com/elixir-tools/elixir-tools.nvim) (formerly known as elixir.nvim). The Neovim plugin has been renamed to help it better fit into it's place in the ecosystem and has given rise to the new elixir-tools family. ### elixir-tools.vscode The elixir-tools family keeps on growing! The release of Credo Language Server naturally mean that there would need to a way to use it with Visual Studio Code, so [elixir-tools.vscode](https://marketplace.visualstudio.com/items?itemName=elixir-tools.elixir-tools) was born. This initial release brings support for Credo Language Server and Elixir filetype and highlighting support. [ElixirLS](https://github.com/elixir-lsp/elixir-ls) support has been omitted since it can happily coexist along side elixir-tools.vscode. If there is demand to add ElixirLS support, that can be done, but at this time there is no need. ## Slow and Steady Wins the Race Over the last 10 months I have been slowly chipping away at this project, making sure that every part is built with excellence in mind. As I built out gen_lsp, I realized that the best way to achieve correctness was to generate most of the code from the official specification. So, I built the [lsp_codegen](https://github.com/mhanberg/lsp_codegen) library. It includes a handwritten generator that conforms to the LSP specification's [JSON Schema](https://json-schema.org) and is used to read the LSP metamodel and to generate Elixir code that includes typespecs and structs for all of the data structures. While building the code generator, I realized that the specification's "Or" type was easy to represent using typespecs, but was actually hard to deserialize from a JSON payload into the Elixir data structures. Inspired by [norm](https://github.com/elixir-toniq/norm) and my friend [Chris Keathley](https://keathley.io), I built [schematic](https://github.com/mhanberg/schematic). This allows me to fully validate, serialize, and deserialize complex data structures. So, to build Credo Language Server, it just took 3 libraries, 2 editor extensions, and a conference talk. 😅 I will be writing more about gen_lsp and schematic in the future. ## What's Next This is just the beginning! 🤗 I have some exciting ideas planned and can't wait to be able to share them with the Elixir community. If you'd like to stay on the bleeding edge of elixir-tools, feel free to join the [Discord](https://discord.gg/6XdGnxVA2A).

Introducing lazyasdf: An Elixir-based TUI for the asdf version manager

Mon, 06 Mar 2023 01:00:00 EST

From Mitchell Hanberg's Blog:

lazyasdf is my first real¹ attempt at making a TUI with Elixir!

asdf is normally used through a command line interface (CLI), lazyasdf presents you with a terminal user interface (TUI) for working with asdf.

I recently fell in love with lazygit and have since dreamed of writing my own TUI programs, but with Elixir.

The TUI provides a quick and intuitive interface for those familiar with the terminal and for those who prefer a graphical application, but the TUI is so much more approachable in my humble opinion when it comes to making your own 😄.

While I find lazyasdf to be an amazing achievement for myself, it isn't super interesting on its own. Let's dive into the specifics of how I was able to build and distribute a TUI application with Elixir.

Ratatouille

None of this would be possible if it weren't for the library ratatouille by Nick Reynolds.

I am not some genius when it comes to terminals or laying out text, this all comes from Ratatouille, which builds off of termbox, which is a [n]curses alternative.

Ratatouille leverages the Elm Architecture of which many of us have grown familiar. Let's take a look at a small Ratatouille program that showcases most of its features.

#!/usr/bin/env elixir

Mix.install([:ratatouille])

defmodule Todos do
  @behaviour Ratatouille.App

  import Ratatouille.View
  import Ratatouille.Constants, only: [color: 1, key: 1]

  @style_selected [
    color: color(:black),
    background: color(:white)
  ]

  @space key(:space)

  @impl true
  def init(_) do
    %{
      todo: %{
        items: %{"buy eggs" => false , "mow the lawn" => true, "get a haircut" => false},
        cursor_y: 0
      }
    }
  end

  @impl true
  def update(model, msg) do
    case msg do
      {:event, %{key: @space}} ->
        {todo, _done} = Enum.at(model.todo.items, model.todo.cursor_y)

        update_in(model.todo.items[todo], & !&1)

      {:event, %{ch: ?j}} ->
        update_in(model.todo.cursor_y, &cursor_down(&1, model.todo.items))

      {:event, %{ch: ?k}} ->
        update_in(model.todo.cursor_y, &cursor_up/1)

      _ ->
        model
    end
  end

  defp cursor_down(cursor, rows) do
    min(cursor + 1, Enum.count(rows) - 1)
  end

  defp cursor_up(cursor) do
    max(cursor - 1, 0)
  end

  @impl true
  def render(model) do
    view do
      panel title: "TODO" do
        for { {t, done}, idx } <- Enum.with_index(model.todo.items) do
          row do
            column size: 12 do
              label if(idx == model.todo.cursor_y, do: @style_selected, else: []) do
                text content: "- ["
                done(done)
                text content: "] #{t}"
              end
            end
          end
        end
      end
    end
  end

  defp done(true), do: text(content: "x")
  defp done(false), do: text(content: " ")
end

Ratatouille.run(Todos)

You should be able to copy the above snippet into a file, make it executable (chmod + x) and run it!

Ratatouille calls for 3 callbacks in your TUI program, init/1, update/2, and render/1.

When the program boots up, the init/1 callback is called and the return value becomes your initial model state.
Whenever the TUI receives user input, the update/2 callback is executed with the message and your current model state.
When that returns, the runtime will call the render/1 callback with the new model state.

The render/1 callback is full of macros which translate to element structs, so it's just an ergonomic DSL. Typing out many structs by hand would be a PITA!

Notes

You have probably observed that, while it is high level compared to raw termbox, Ratatouille is still sort of "low level" as an application framework.

We still have to manually track and move our cursor position, as well as index into our data structures to pull out the right data for that position.

Burrito

Now the normal problem with Elixir apps is that you have to have Elixir and Erlang on your machine to run them, as well as keep track of the version of them you have installed to make sure they are compatible, as well as write aliases to run escripts and Mix tasks, yada yada.

This is where Burrito comes in!

Burrito utilizes Zig to bundle up your application, the BEAM, and the Runtime all into one tidy executable that you can distribute at your leisure!

In the end, once we run MIX_ENV=prod mix release, Burrito will create binaries for each of our specified target platforms, and you can just copy those onto your computer and run them

The Burrito project is lead by Digit.

Homebrew

To make any program useful, it is help to be able to install it easily.

Homebrew is the primary way of accomplishing this on MacOS (my preferred operating system) and you can easily host your own collection of Homebrew packages with your own Tap!

Since lazyasdf has some quirky dependencies, the formula (what Homebrew calls a package definition) is a little interesting.

class Lazyasdf < Formula
  desc "TUI for the asdf version manager"
  homepage "https://github.com/mhanberg/lazyasdf"
  url "https://github.com/mhanberg/lazyasdf/archive/refs/tags/v0.1.1.tar.gz"
  sha256 "787da19809ed714c569c8bd7df58d55d7389b69efdf1859e57f713d18e3d2d05"
  license "MIT"

  bottle do
    root_url "https://github.com/mhanberg/homebrew-tap/releases/download/lazyasdf-0.1.1"
    sha256 cellar: :any_skip_relocation, monterey: "f489e328c19954d62284a7154fbc8da4e7a1df61dc963930d291361a7b2ca751"
  end

  depends_on "elixir" => :build
  depends_on "erlang" => :build
  depends_on "gcc" => :build
  depends_on "make" => :build
  depends_on "python@3.9" => :build
  depends_on "xz" => :build

  depends_on "asdf"

  on_macos do
    on_arm do
      resource "zig" do
        url "https://ziglang.org/download/0.10.0/zig-macos-aarch64-0.10.0.tar.xz"
        sha256 "02f7a7839b6a1e127eeae22ea72c87603fb7298c58bc35822a951479d53c7557"
      end
    end

    on_intel do
      resource "zig" do
        url "https://ziglang.org/download/0.10.0/zig-macos-x86_64-0.10.0.tar.xz"
        sha256 "3a22cb6c4749884156a94ea9b60f3a28cf4e098a69f08c18fbca81c733ebfeda"
      end
    end
  end

  def install
    zig_install_dir = buildpath/"zig"
    mkdir zig_install_dir
    resources.each do |r|
      r.fetch

      system "tar", "xvC", zig_install_dir, "-f", r.cached_download
      zig_dir =
        if Hardware::CPU.arm?
          zig_install_dir/"zig-macos-aarch64-0.10.0"
        else
          zig_install_dir/"zig-macos-x86_64-0.10.0"
        end

      ENV["PATH"] = "#{zig_dir}:" + ENV["PATH"]
    end

    ENV["PATH"] = (Formula["python@3.9"].opt_libexec/"bin:") + ENV["PATH"]

    system "mix", "local.hex", "--force"
    system "mix", "local.rebar", "--force"

    ENV["BURRITO_TARGET"] = if Hardware::CPU.arm?
      "macos_m1"
    else
      "macos"
    end

    ENV["MIX_ENV"] = "prod"
    system "mix", "deps.get"
    system "mix", "release"

    if OS.mac?
      if Hardware::CPU.arm?
        bin.install "burrito_out/lazyasdf_macos_m1" => "lazyasdf"
      else
        bin.install "burrito_out/lazyasdf_macos" => "lazyasdf"
      end
    end
  end

  test do
    # this is required for homebrew-core
    system "true"
  end
end

Here we can see all of lazyasdf's dependencies.

It requires

Elixir/Erlang: self-explanatory
asdf: self-explanatory
gcc, make: used to compile the termbox NIF bindings
Python 3.9: The termbox NIF uses a python script. For some reason it works with 3.9 and not 3.11, so I pinned it at 3.9 🤷‍♂️.
zig,xz: Burrito uses these two.

Burrito specifically uses Zig 0.10.0, not 0.10.1, so we have to specify it as a resource and download it from the Zig website. Luckily, they provide pre-compiled binaries for both of our target platforms, so we can just download, untar, and add them to our PATH!

The Python dependency is even more quirky. The termbox scripts use the unversioned python executable, but Homebrew does not link those by default, so we have to manually add the unversioned one to our PATH for it to work.

Voilà!

Notes

Since this is a 3rd party Tap, the bottles that are generated are for an older version of Intel Mac, so those won't be very useful to anybody.

But if I were to merge this formula into homebrew-core, they would be bottled using the secret Homebrew GitHub Actions runners that can bottle it for all the OS's and architectures.

The Future

Ratatouille is incredible as it is today, but there is a lot of room for improvement.

As time allows, I hope to:

Contribute to Ratatouille to allow more complex UI features like scrollbars and dynamic size information for elements.
Create bindings for termbox2 (the next iteration of termbox).
Create a higher level toolkit for building TUIs with Ratatouille, including menus, inputs, dialogs, etc.

Thanks for reading!

Previously, I have made a fzf clone using Ratatouille. You can find it in my dotfiles. ↩

Team Retrospectives: A How-To Guide for Team Building

Thu, 02 Mar 2023 20:25:16 +0000

From Binary Noggin:

The post Team Retrospectives: A How-To Guide for Team Building appeared first on Binary Noggin.

Physical knobs & userspace drivers in Elixir

Wed, 01 Mar 2023 04:00:00 +0000

From Underjord.io: I like production gear. Audio, video and .. miscellaneous. I like things that seem like they’ll make me oh-so-very productive. I’m a sucker prosumer as a hobby. Let’s talk about Elgato, Elixir and why I never actually get anything done. This is unfortunately not sponsored by a prosumer brand, or anyone, that’d have been something. Ad-style pitch for a business-thing: I help companies find competent, capable or promising Elixir developers. If you build in Elixir and want to spend less time finding great candidates, reach out.

TIL - Implementing Encoder for NifStructs

Tue, 27 Dec 2022 00:08:54 +0100

From Maarten van Vliet: I am currently using Rustler, a tool that allows for Elixir to interact with the Rust ecosystem. As a newcomer to Rust, working on Rust-Elixir crossover libraries helps me understand its quirks. Today, I was trying to use a SQL parser in Rust and convert the results to Elixir terms. Rustler’s NifStructs feature made this process convenient. However, I encountered an issue with a data structure defined as follows: #[derive(NifStruct)] #[module = "SqlParser.

ElixirConf 2022 Productivity Takeaways

Fri, 09 Dec 2022 18:29:23 +0000

From Binary Noggin:

I am a huge fan of improving development workflows. The less I have to think about incidental things, the more I can concentrate on the problems that matter. One talk from ElixirConf 2022 helped improve my development workflow. Jason Axelson doled out some essential tips to speed up Elixir development. A few quick wins for […]

The post ElixirConf 2022 Productivity Takeaways appeared first on Binary Noggin.

Guarantees with Ecto.Repo.update_all/3

Fri, 09 Dec 2022 18:19:27 +0000

From Binary Noggin:

We all want guarantees. We can get guarantees on our automobiles, homes, phones, shoes, food, and even our pets. We’ll take a guarantee in, on, or about anything. As software developers, our clients want guarantees for a whole host of things, from delivery dates to service uptime. Some of those are difficult to promise. What […]

The post Guarantees with Ecto.Repo.update_all/3 appeared first on Binary Noggin.

The Lifecycle of a Phoenix LiveView

Wed, 30 Nov 2022 21:36:13 +0000

From Binary Noggin:

The LiveView request lifecycle runs twice when a connection is first made to your application. It runs once to render static content for web crawlers, search engines, and other non-javascript-enabled clients. The second pass occurs when the browser establishes the websocket connection that sends events and data back and forth between the application and the […]

The post The Lifecycle of a Phoenix LiveView appeared first on Binary Noggin.

Video - Why use a database?

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: A short video on databases. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - Sonic Pi

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: Code has always been about creative pursuit for me. This video showcases Sonic Pi. It is an open source project that I really appreciate. Sonic Pi enables live coding of music. If you are already a programmer it can turn your hard-earned, often dry, programming capabilities into musical potential. If you know music, you might just learn programming. If you know neither it is a fantastically fun place to start.

Video - Reacting to the Phoenix Keynote 2022

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: I share my reactions to the Phoenix keynote at ElixirConf 2022. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - Is it all queues?

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: Are computers really all about queues? At some level. Probably. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - Chat bots as UI at ElixirConf Africa

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: My presentation from ElixirConf Africa. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - Does terminology matter?

Fri, 04 Nov 2022 04:00:00 +0000

From Underjord.io: A short video on the importance of terminology in computing. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Complex Systems All The Way Down

Mon, 24 Oct 2022 04:00:00 +0000

From Underjord.io: As part of running Underjord I’ve done both mentorship and some teaching. Both in the form of a working relationship where I have seniority and am responsible for supporting their learning as well as mentoring entirely external people of varying experience levels. I find it incredibly hard to transmit everything I think people need to get familiar with when they want to do development. Why? Well, I learned it all incrementally.

Building Embedded Systems in the Modern Era

Wed, 12 Oct 2022 00:00:13 +0000

From Binary Noggin:

The post Building Embedded Systems in the Modern Era appeared first on Binary Noggin.

Fear-driven development

Fri, 07 Oct 2022 04:00:00 +0000

From Underjord.io: Twice burnt, getting the hang of this fire thing. There’s a thing I’m wary of with both companies and developers: when they seem to operate mostly on fear. In the case of companies, fear can lead to heavy screening during the hiring process, heavy-handed, detail-oriented project management or distrust towards employees. To my mind, these things either come from the basic mode of operation of some founding member or from cultural scars caused by a bad hire, a runaway project or very anxious management.

Why can't I find a CMS?

Mon, 26 Sep 2022 04:00:00 +0000

From Underjord.io: I’ve been trying to address this particular topic and I find it challenging. It is a topic that’s very easy to turn into a negative rant and that’s not what I like to do. If you enjoy any of the stacks I dismiss in this post, please know that is not a jab at you or your work. I have worked in these stacks and I’ve mostly transitioned away from them where they aren’t necessary.

Video - Self-hosting: Mattermost

Fri, 16 Sep 2022 04:00:00 +0000

From Underjord.io: Slack, Teams, teamchat. We all use them in our jobs. It is unclear whether that’s even legal. I wanted to present one of the more well-known open source options and how to get started with it. This video is a collaboration with GleSYS. Keep them in mind for your cloud and data center needs in the Nordics. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.

Tradition and Ritual in Software, or The Unwritten Code of Code

Mon, 12 Sep 2022 04:00:00 +0000

From Underjord.io: I’ve been thinking about shared experiences: culture and tradition. As the seed of this was written close to the holidays, it might be that they are to blame. But this post isn’t about Christmas or the new year; it’s about my reflections on these human matters and how they apply in the software development world. How we run dangerous commands Have you ever had to run a potentially dangerous command on a production server?

Video - My Tools, the current product stack

Fri, 26 Aug 2022 05:00:00 +0000

From Underjord.io: In this very serious video I will tell you exactly how you must build your products. Actually, I’m just outlining the tools I’d typically look at and consider right now. I hope you enjoy. I rather like the intro personally. Also on YouTube. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - LiveView on Nerves

Fri, 26 Aug 2022 04:00:00 +0000

From Underjord.io: A video on doing LiveView with Nerves and having fun with input devices. Published as I finish up my backlog of publishing all my videos to my site. It should calm down now. This was also more thoroughly covered in text in this post. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - Self-hosting: Plausible Analytics

Thu, 25 Aug 2022 04:00:00 +0000

From Underjord.io: This video covers the steps to set up Plausible Analytics. Previously published on YouTube and part of me catching up on site publishing :) function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Dynamic Form Inputs in Elixir LiveView

Thu, 25 Aug 2022 00:00:04 +0000

From Binary Noggin:

I recently found myself addressing a product requirement involving a form with input fields generated from a list of data we retrieved from a third-party provider. This requirement proved challenging as the prescribed user experience stretched a little beyond the familiar tools for form building in Elixir. Even more frustrating, the wireframes presented the data […]

The post Dynamic Form Inputs in Elixir LiveView appeared first on Binary Noggin.

Video - Reacting to React

Sun, 21 Aug 2022 04:00:00 +0000

From Underjord.io: Out of freak fortune I haven’t significantly used React. This was an experiment in just diving in and trying to use it. Be warned, if you know React it might hurt. Let me know you like it. This video has been on the YouTube channel for some time but I’m catching up on the transcoding and publishing here. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.

Video - Why Self-Host

Sat, 20 Aug 2022 04:00:00 +0000

From Underjord.io: A video on why you should consider hosting your own services and data. Especially in the current EU legal landscape. Created in collaboration with GleSYS, a swedish data centre and cloud provider. This video lays the explanatory groundwork for a series of guides for setting up some self-hosted services. It went up on YouTube a while back, I’m catching up on the website publishing side :) function switch_video(element) { var src = element.

Video - What Is: Phoenix LiveView

Sat, 20 Aug 2022 04:00:00 +0000

From Underjord.io: A video explainer on what Phoenix LiveView is. Published late to this site, has been up on YouTube for some time. I’m catching up :) function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

An iPad retrospective

Thu, 11 Aug 2022 06:34:25 +0300

From Posts on Claudio Ortolina:

I’ve been working on iPad full-time for a while now, and it’s always a source of surprise when I talk about it with other people. This post aims at summarising the why behind this preference of mine.

Planting a seed

I spent 2019 on the Turkish West Coast, in a small town near Izmir. It’s a lovely place where everyone knows each other, and where we now have friends and people we care about.

I was working as a backend engineer on PSPDFKit Server, a product written in Elixir and packaged via Docker, on my trusty old 2014 11” Macbook Air. A wonderful machine - powerful for its size, and featherweight.

Around April, a few things happened at the same time:

Spring came: warm, sunny, and ideal to start working outside in the shade of a café.
A set of requirements that involved way more work with Docker, and consequently a much larger use of CPU, battery, and internet bandwidth.
The need to finally increase my editor font size to 14pt.

It quickly became apparent that I was asking too much out of my laptop.

As I’ve been writing software in the shell for years, I switched to a remote setup using a powerful remote server. 32 cores, very large bandwidth, almost the same experience as working locally (if you take into account the occasional latency problem, well mitigated by mosh).

Screen size, however, became an issue: 14pt on a 11” screen is crammed, and difficult to use.

I thought about purchasing a new laptop, but doing that from Turkey proved to be difficult, because of the different keyboard layout.

I decided I would try a week long experiment using the other device I had, a 3rd generation 12.9 iPad Pro (with its keyboard) which I mainly used for entertainment. I figured that given my remote development setup, I could still get things done.

The experience was great: I loved the screen size and ratio, and the retina screen made text very easy to read (to the point that I could go back to 12pt, which worked really well in terms of information density). I could work the entire day without worrying about the battery, and enjoy the spring/summer season.

While coding was (surprisingly) pleasant considering the fiddly setup, other activities were proving to be more difficult: apps like Slack and Google Docs were (and in some cases still are) cumbersome to use, with very little support for keyboard shortcuts, and of substantial inferior quality compared to their desktop counterparts. I got by, occasionally dusting off the Macbook Air for specific tasks that wouldn’t work at all on the iPad (e.g. work that required using the Chrome Web Inspector).

Then February 2020 came, we moved back to England and the pandemic started. Like many others, we spent most of our time at home, where I could use a decent Mac Mini with a nice keyboard and external screen.

Despite this change, a seed had been planted in my head: could an iPad eventually replace a desktop computer altogether for a “hardcore” user like me?

Unexpected changes

Around spring 2020, my role changed, and I started managing a team. Coding became a past-time activity that I kept maintaining for fun, and 99% of my work now involved planning, communication with people, and some form of documents and task lists.

In December 2020, a family situation forced us to quickly pack our bags and fly to Turkey again. I ended up taking with me all devices (which sounds ridiculous - I know).

The following months are a blur - I remember working from all sorts of places: the car, parking lots, hospital cafés, the balcony table, hotel rooms. I once had a meeting in a service station.

That’s how the iPad came back in full force: always on, always charged, with data always in sync. Pair it with the Apple Pencil, and a pair of earphones, and it gave me the ability to adapt work to a complicated personal life.

I was happy to see that software had gotten better: Safari gained a desktop mode which supported all sorts of complex web apps, and all other apps improved to the point of being at least usable (Google Docs, I’m looking at you). Notable mentions go to Agenda, Mindnode, and Fantastical, which set a very high bar for quality software in general.

Later in the year, things started to calm down and even if I could use the Mac Mini, I would prefer the iPad. I invested in a desk stand which would let me prop it to a decent height, connect it to a good keyboard and mouse, and happily went about my work day.

Introspection

I started asking myself what is it about working on the iPad that I love. What started as a challenge motivated by specific constraints evolved now into a solid preference.

I don’t think I’m making a point - as in trying to be clever or different by not using a traditional computer. There’s plenty of people who do that, and if you search on YouTube you will find all sorts of tutorials on how to try and work around iPadOS’s limitations (e.g. having a Raspberry PI as a sidecar mini-server) to achieve things that are indeed way easier with a laptop.

The iPad fits my mental model of getting things done (tasks instead of files), and it doesn’t get in the way. It’s got great security defaults, it’s encrypted, and automatically backed up. If I buy a new one, I can easily transfer all my data and be up and running in a couple of hours.

The iPad lets me focus on what I want to achieve, as opposed to losing myself in endless maintenance.

I take notes of points of friction, and every once in a while, I review my workflows: if I wanna change anything, I’ll test a different application (after making sure my data is portable), and move on.

Binary Noggin Ranks #20 on Kansas City Business Journal Fast 50 List

Thu, 28 Jul 2022 00:00:24 +0000

From Binary Noggin:

The post Binary Noggin Ranks #20 on Kansas City Business Journal Fast 50 List appeared first on Binary Noggin.

Front-End Testing in Phoenix With Wallaby

Wed, 29 Jun 2022 00:00:26 +0000

From Binary Noggin:

Why is front-end testing even a thing? We have LiveView, right? I can run tests on my components and everything is magical. What is Wallaby? You may have heard of Wallaby at the Big Elixir when Britton Broderick gave a talk about using it with LiveView, or maybe you knew of it before that. If […]

The post Front-End Testing in Phoenix With Wallaby appeared first on Binary Noggin.

The Binary Noggin Breakdown: Why Is Collaboration Important in Software Development?

Tue, 14 Jun 2022 00:00:30 +0000

From Binary Noggin:

The post The Binary Noggin Breakdown: Why Is Collaboration Important in Software Development? appeared first on Binary Noggin.

What ID3v2 could have been

Tue, 07 Jun 2022 04:00:00 +0000

From Underjord.io: Speculations and specifications. If you were a Winamp user back in the day, or curate an MP3 collection currently, you might recognize the humble ID3 tag. It is what the metadata in the MP3 file is made up of. First it was pretty limited in the version later dubbed ID3v1. Like any good 2.0 they added a ton more fields, features, removed character limits and it was suddenly ID3v2. The latest spec is ID3v2.

The Comprehensive Guide to Elixir's List Comprehension

Thu, 02 Jun 2022 01:00:00 -04

From Mitchell Hanberg's Blog: ## What is it? The `for` special form, also known as a list comprehension, is a construct designed for concise and powerful enumerable transformation in Elixir. It looks very similar to a "for loop" in other languages like JavaScript and C, but rather than being a language construct, it is an expression (like everything else in Elixir). This means that it evaluates to a value that can be bound to a variable. You may have heard this before as "statement vs expression". ```elixir last_names = for friend <- friends do friend.last_name end ``` Before reading this rest of this article, I suggest you read the list comprehension guide on [elixir-lang.org](https://elixir-lang.org/getting-started/comprehensions.html). I will go over some of the same details, but hopefully will go much more in depth. ## Generators The primary ingredient in a comprehension is the generator. The only other place you will see this "left arrow" syntax (`lhs <- rhs`) is in the `with` special form. The right hand side is the enumerable you want to loop over and the left hand side is the intermediate pattern you want to match on during each iteration. This is a normal pattern, so you can pattern match like you would anywhere else. ```elixir friends = [ %{first_name: "Joe", last_name: "Swanson"}, %{first_name: "Greg", last_name: "Mefford"}, %{first_name: "Erik", last_name: "Plostins"}, ] for %{last_name: last_name} <- friends do last_name end # ["Swanson", "Mefford", "Plostins"] ``` ### Multiple Generators Comprehensions are very concise in that you can declare multiple generators, allowing you to generate every permutation of both enumerables. A great example is generating a list of coordinate pairs from a range of `x` values and `y` values. A key detail to recognize is that the both values are yielded to the same block, so the result is a flat list. ```elixir for x <- 0..99, y <- 0..99 do {x, y} end # [{0, 0}, {0, 1}, {0, 2}, ...] ``` The counter example using [`Enum.map/2`](https://hexdocs.pm/elixir/Enum.html#map/2) is not nearly as readable and demonstrates that you need to remember to flatten the outer loop, or else you'll get a list of lists. ```elixir Enum.flat_map(0..99, fn x -> Enum.map(0..99, fn y -> {x, y} end) end) # [{0, 0}, {0, 1}, {0, 2}, ...] ``` ### Generators work with maps too The comprehension works with anything that implements the `Enumerable` protocol, so you can iterate through a map as well. The generator will yield each key/value pair of the given map. ```elixir dictionary = %{ "low-latency" => "short delay before a transfer of data begins following an instruction for its transfer", "distributed" => "(of a computer system) spread over several machines, especially over a network", "fault-tolerant" => "relating to or being a computer or program with a self-contained backup system that allows continued operation when major components fail" } for {word, definition} <- dictionary do IO.puts "#{word}: #{definition}" end ``` As seen above, we can iterate through a `Range` as well. ```elixir for x <- 0..99, y <- 0..99 do {x, y} end # [{0, 0}, {0, 1}, {0, 2}, ...] ``` ### Bitstring generators The generators we've seen so far have been "list generators". The other type of generator is the "bitstring generator". The bitstring generator allows you to easily loop over a bitstring while correctly parsing bytes. For a primer on bitstrings, please see the fantastic guide on [elixir-lang.org](https://elixir-lang.org/getting-started/binaries-strings-and-char-lists.html#bitstrings). This is often very useful when parsing binary protocols like database protocols. Below is an example that demonstrates that each iteration of the comprehension reads the message length and then uses it to know how much more of the bitstring to read next. While the previous examples could be translated into various form of `Enum.map/2`, this example can only be achieved with normal recursion. ```elixir bitstring = <<1, "I", 6, "really", 4, "love", 4, "list", 14, "comprehensions", 1, "!">> # <<1, 73, 6, 114, 101, 97, 108, 108, 121, 4, 108, 111, 118, 101, 4, 108, 105, # 115, 116, 14, 99, 111, 109, 112, 114, 101, 104, 101, 110, 115, 105, 111, 110, # 115, 1, 33>> for <> do message end # ["I", "really", "love", "list", "comprehensions", "!"] ``` The example using recursion looks like: ```elixir defmodule For do def loop(""), do: [] def loop(<>) do [message | loop(rest)] end end bitstring = <<1, "I", 6, "really", 4, "love", 4, "list", 14, "comprehensions", 1, "!">> For.loop(bitstring) # ["I", "really", "love", "list", "comprehensions", "!"] ``` To compare the two styles, let's look at the syntax of the generator in the comprehension example and the second function head of `loop` in the function example. In the function example, you'll see that we pattern match on the bitstring in a similar manner to who you pattern match on a list. We pull several individual items off the beginning of the bitstring (`message_length::integer, message::binary-size(message_length)`) and we pattern match on the "rest" of the bitstring with `rest::binary`. The list equivalent looks like: ```elixir defmodule For do def loop([]), do: [] def loop([_length, message | rest]) do [message | loop(rest)] end end list = [1, "I", 6, "really", 4, "love", 4, "list", 14, "comprehensions", 1, "!"] For.loop(list) # ["I", "really", "love", "list", "comprehensions", "!"] ``` Now if we compare this to the bitstring generator, we can see the similarity (_**with a caveat**_). The `lhs` of the bitstring generator is the pattern match on the individual items and the `rhs` is pattern matching on the "rest". The caveat is that `bitstring` here is not actually the "rest" on each iteration, it is still the entire bitstring. I find this the best analogy to describe how the bitstring generator works since it is different enough from the "normal" list generator. ```elixir # 👇 individual item 👇 individual item 👇rest for <> do # 👇 this will print the same thing every time IO.inspect(bitstring) message end ``` ### Chaining generators List comprehensions allow you to chain generators together by using the `lhs` value from a generator in the `rhs` of a subsequent generator. Here's an example that demonstrates getting a list of all of your friends hobbies: ```elixir friends = [ %{name: "Derek", hobbies: ["Movies", "Hot Sauce"]}, %{name: "Joe", hobbies: ["Yu-Gi-Oh!", "Tattoos"]}, %{name: "Andres", hobbies: ["Photoshop", "Oreos", "Cereal"]}, ] for %{hobbies: hobbies} <- friends, hobby <- hobbies do hobby end # ["Movies", "Hot Sauce", "Yu-Gi-Oh!", "Tattoos", "Photoshop", "Oreos", "Cereal"] ``` ### Generators filter non-matching lhs values If the match expression in the `lhs` of a generator does not match on the value yielded from the `rhs`, it will be rejected, and the list comprehension will move on to the next element in the enumerable. This is slightly surprising behavior at first and should be kept in mind when using list comprehensions. The following example might lead to a bug in your program. ```elixir friends = [ %{"name" => "Derek"}, %{name: "Joe"} ] for %{name: name} <- friends do name end # ["Joe"] ``` If you were to have written this program using `Enum.map/2`, you would have ran into a function clause error. ```elixir friends = [ %{"name" => "Derek"}, %{name: "Joe"} ] Enum.map(friends, fn %{name: name} -> name end) # ** (FunctionClauseError) no function clause matching in :erl_eval."-inside-an-interpreted-fun-"/1 # # The following arguments were given to :erl_eval."-inside-an-interpreted-fun-"/1: # # # 1 # %{"name" => "Derek"} # # (stdlib 3.17.1) :erl_eval."-inside-an-interpreted-fun-"/1 # (stdlib 3.17.1) erl_eval.erl:834: :erl_eval.eval_fun/6 # (elixir 1.13.3) lib/enum.ex:1593: Enum."-map/2-lists^map/1-0-"/2 ``` This behaviour can be useful! If you only wanted to iterate over configuration options that are enabled, you could write something like this: ```elixir configs = [ %{name: :feature_a, enabled: true}, %{name: :feature_b, enabled: false}, %{name: :feature_c, enabled: true} ] for %{enabled: true} = config <- configs do config end # [%{name: :feature_a, enabled: true}, %{name: :feature_c, enabled: true}] ``` ## Filters Now that we've talked about _generator filtering_, let's talk about _Filters_. So far we have seen one type of "argument" that can be passed to the comprehension, the generator. Another "argument" is the filter! Let's look at a quick example. In this example, we iterate over a list of employees, filter based on the employees status, and return a list of the employee's names ```elixir employees = [ %{name: "Eric", status: :active}, %{name: "Mitch", status: :former}, %{name: "Greg", status: :active} ] for employee <- employees, employee.status == :active do employee.name end # ["Eric", "Greg"] ``` As with generators, filters can use values bound in a previous step of the comprehension. And like generators, you can use multiple filters as well. You can even mix and match them! ```elixir employees = [ %{ name: "Eric", status: :active, hobbies: [%{name: "Text Adventures", type: :gaming}, %{name: "Chickens", type: :animals}] }, %{ name: "Mitch", status: :former, hobbies: [%{name: "Woodworking", type: :making}, %{name: "Homebrewing", type: :making}] }, %{ name: "Greg", status: :active, hobbies: [ %{name: "Dungeons & Dragons", type: :gaming}, %{name: "Woodworking", type: :making} ] } ] for employee <- employees, employee.status == :active, hobby <- employee.hobbies, hobby.type == :gaming do {employee.name, hobby} end # [ # {"Eric", %{name: "Text Adventures", type: :gaming}}, # {"Greg", %{name: "Dungeons & Dragons", type: :gaming}} # ] ``` At this point we can recognize that the list comprehension has the characteristics of a function with [variadic arguments](https://en.wikipedia.org/wiki/Variadic_function). If we were to write our own `for` using plain functions, we'd have to pass it a list of callbacks to evaluate and a final callback to do the mapping. While we aren't necessarily concerned with how we'd implement `for` as a plain function, it's important to recognize aspects that are "different" from "normal" constructs in the language. One of the great things about the list comprehension is that it allows you to operate on `Enumerable` data structures in fewer passes (usually 1) than when using the `Enum` module. We can write our previous example using functions like so: ```elixir employees = [ %{name: "Eric", status: :active}, %{name: "Mitch", status: :former}, %{name: "Greg", status: :active} ] employees |> Enum.filter(fn employee -> employee.status == :active end) |> Enum.map(fn employee -> employee.name end) # ["Eric", "Greg"] employees |> Enum.reduce([], fn employee, acc -> if employee.status == :active do [employee.name | acc] else acc end end) |> Enum.reverse() # ["Eric", "Greg"] :lists.filtermap( fn employee -> if employee.status == :active do {true, employee.name} else false end end, employees ) # ["Eric", "Greg"] ``` You can see benchmarks of all of these styles of "filter map" [here](https://github.com/mhanberg/notebooks/blob/c0c0c710fd5ca7a6f36d5acdca9043911d49044d/notebooks/list_benchmarks.livemd). ## Options Now that we've covered the basic principles of the list comprehension, we can explore the various options that can be passed to augment it's behavior. The default behavior is to act more or less like `Enum.map/2` with regard to the return type. As of this writing, there are three options available: `:uniq`, `:into`, and `:reduce` ### :uniq `:uniq` is the least interesting of the available options, but still quite powerful. It simply ensures that the return result will only contain unique values. ```elixir employees = [ %{ name: "Eric", status: :active, hobbies: [%{name: "Text Adventures", type: :gaming}, %{name: "Chickens", type: :animals}] }, %{ name: "Mitch", status: :former, hobbies: [%{name: "Woodworking", type: :making}, %{name: "Homebrewing", type: :making}] }, %{ name: "Greg", status: :active, hobbies: [ %{name: "Dungeons & Dragons", type: :gaming}, %{name: "Woodworking", type: :making} ] } ] for employee <- employees, hobby <- employee.hobbies, uniq: true do hobby.name end # ["Text Adventures", "Chickens", "Woodworking", "Homebrewing", "Dungeons & Dragons"] ``` You can see benchmarks of all of these styles of "map uniq" [here](https://github.com/mhanberg/notebooks/blob/ae5362fded45465e22e74b9d310715e7852502d8/notebooks/list_benchmarks.livemd#results-mapuniq). ### :into `:into` is where things start to get interesting. The default behavior for a list comprehension behaves more or less like a "map" operation, meaning that the expression evaluates to a list. The `:into` option allows you to instead push the value returned by each iteration into a _collectable_. A data structure is collectable if it implements the [Collectable](https://hexdocs.pm/elixir/Collectable.html) protocol. If you aren't familiar with protocols, you have already been using them! The `Enum` module is a set of functions that operate on data structures that implement the [Enumerable](https://hexdocs.pm/elixir/Enumerable.html) protocol. The builtin data structures that implement the `Enumerable` protocol are the `List`, `Range`, `Map`, and `MapSet` types. The builtin data structures that implement the `Collectable` protocol are `List`, `Map`, `MapSet`, and `BitString`. The `Enum` function that you would use to take advantage of this protocol is [Enum.into/2](https://hexdocs.pm/elixir/Enum.html#into/3). Let's take a look at some examples. #### List Using a list as the `:into` actually doesn't change the behavior at all! ```elixir employees = [ %{ name: "Eric", status: :active, hobbies: [%{name: "Text Adventures", type: :gaming}, %{name: "Chickens", type: :animals}] }, %{ name: "Mitch", status: :former, hobbies: [%{name: "Woodworking", type: :making}, %{name: "Homebrewing", type: :making}] }, %{ name: "Greg", status: :active, hobbies: [ %{name: "Dungeons & Dragons", type: :gaming}, %{name: "Woodworking", type: :making} ] } ] for employee <- employees, employee.status == :active, hobby <- employee.hobbies, hobby.type == :gaming, into: [] do {employee.name, hobby} end # [ # {"Eric", %{name: "Text Adventures", type: :gaming}}, # {"Greg", %{name: "Dungeons & Dragons", type: :gaming}} # ] ``` #### Map But if we use a map, we can see that it pushes each key/value pair into the map that you pass for the option. Usually I use this with an empty map (`%{}` or `Map.new()`), but let's look at an example using a non-empty map. ```elixir employees = [ %{ name: "Eric", status: :active, hobbies: [%{name: "Text Adventures", type: :gaming}, %{name: "Chickens", type: :animals}] }, %{ name: "Mitch", status: :former, hobbies: [%{name: "Woodworking", type: :making}, %{name: "Homebrewing", type: :making}] }, %{ name: "Greg", status: :active, hobbies: [ %{name: "Dungeons & Dragons", type: :gaming}, %{name: "Woodworking", type: :making} ] } ] base_map = %{ "Mitch" => %{ name: "Reading", type: :learning }, "Greg" => %{ name: "Traveling", type: :expensive } } for employee <- employees, employee.status == :active, hobby <- employee.hobbies, hobby.type == :gaming, into: base_map do {employee.name, hobby} end # %{ # "Eric" => %{name: "Text Adventures", type: :gaming}, # "Greg" => %{name: "Dungeons & Dragons", type: :gaming}, # "Mitch" => %{name: "Reading", type: :learning} # } ``` Here we can observe three things. - The comprehension evaluates to a map. - The `"Mitch"` key and its value were preserved in the final output. - The `"Greg"` key's value in the `base_map` was overwritten by the value yielded during the comprehension with the same key. If our comprehension were to have returned multiple key/value pairs with identical keys, the last one would have won. This option is very useful for transforming maps. Since iterating over a map with an `Enum` function turns it into a list of 2-tuples, you always need to pipe the return value into `Enum.into/2` or `Map.new/1`. ```elixir employees = [ %{ name: "Eric", status: :active, hobbies: [%{name: "Text Adventures", type: :gaming}, %{name: "Chickens", type: :animals}] }, %{ name: "Mitch", status: :former, hobbies: [%{name: "Woodworking", type: :making}, %{name: "Homebrewing", type: :making}] }, %{ name: "Greg", status: :active, hobbies: [ %{name: "Dungeons & Dragons", type: :gaming}, %{name: "Woodworking", type: :making} ] } ] base_map = %{ "Mitch" => %{ name: "Reading", type: :learning }, "Greg" => %{ name: "Traveling", type: :expensive } } employees |> Enum.filter(fn employee -> employee.status == :active end) |> Enum.flat_map(fn employee -> employee.hobbies |> Enum.filter(fn hobby -> hobby.type == :gaming end) |> Enum.map(fn hobby -> {employee.name, hobby} end) end) |> Enum.into(base_map) # %{ # "Eric" => %{name: "Text Adventures", type: :gaming}, # "Greg" => %{name: "Dungeons & Dragons", type: :gaming}, # "Mitch" => %{name: "Reading", type: :learning} # } ``` #### Strings and BitStrings You can build strings and bitstrings with the `:into` option as well! This is useful when you want to build a string or a binary out of a list or map all in one pass. Let's take a look at an example of creating an "attribute string" for use with HTML. ```elixir attributes = [ class: "font-bold text-red-500 underline", id: "error-text", data_controller: "error-controller" ] for {property, value} <- attributes, into: "" do property = property |> to_string() |> String.replace("_", "-") ~s| #{property}="#{value}"| end # " class=\"font-bold text-red-500 underline\" id=\"error-text\" data-controller=\"error-controller\"" ``` ### :reduce My favorite option to the comprehension is `:reduce`! Reduce allows us to change the comprehension from behaving like a "map" operation to a "reduce" operation. This means that it will loop over an enumerable, but collect an "accumulator" instead. Let's take a look at the first example in the `Enum.reduce/3` documentation and then convert it to a comprehension. This example produces the sum of a list of integers. ```elixir Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end) # 6 ``` We can express this as a comprehension like so: ```elixir for x <- [1, 2, 3], reduce: 0 do acc -> x + acc end # 6 ``` There are two immediate things we can observe. First, the `:reduce` option takes a value that is to be used as the first value of the accumulator. Second, the comprehension in this mode includes a slightly different syntax. Here the inside of the block includes the "arg(s) and right arrow" syntax that you see in anonymous functions and case expressions. This is the syntax that allows the comprehensions to yield the accumulator to the block on every iteration. The additional syntax is the same as the other places you have probably seen it; you can pattern match and pass additional clauses! ```elixir directions = [ left: 2, up: 1, down: 5, right: 6 ] # You can't move below or to the left of 0. starting_position = {0, 0} for {dir, movement} <- directions, reduce: starting_position do {x, y} when dir == :left and x - movement > 0 -> {x - movement, y} {x, y} when dir == :down and y - movement > 0 -> {x, y - movement} {x, y} when dir == :up -> {x, y + movement} {x, y} when dir == :right -> {x + movement, y} position -> IO.puts("Not possible to move #{dir} by #{movement} when you care located at #{inspect(position)}") position end # {6, 1} ``` Above we can observe that we've written 5 different clauses, pattern matched on the shape of the data, as well as added guard clauses that capture the data in the generator and the accumulator. The beauty of using a comprehension as a reducer is the ability to use multiple generators and act on them as if they are one level of iteration. ```elixir friends = [ %{name: "Derek", hobbies: ["Movies", "Hot Sauce"]}, %{name: "Joe", hobbies: ["Yu-Gi-Oh!", "Tattoos"]}, %{name: "Andres", hobbies: ["Photoshop", "Oreos", "Cereal"]}, ] for %{hobbies: hobbies, name: name} <- friends, hobby <- hobbies, reduce: [] do tagged_hobbies -> [{name, hobby} | tagged_hobbies] end # [ # {"Andres", "Cereal"}, # {"Andres", "Oreos"}, # {"Andres", "Photoshop"}, # {"Joe", "Tattoos"}, # {"Joe", "Yu-Gi-Oh!"}, # {"Derek", "Hot Sauce"}, # {"Derek", "Movies"} # ] ``` To write this without a comprehension it would look something like: ```elixir Enum.reduce(friends, [], fn %{name: name, hobbies: hobbies}, tagged_hobbies -> new_hobbies = Enum.map(hobbies, fn hobby -> {name, hobby} end) new_hobbies ++ tagged_hobbies end) ``` ## Conclusion If you've made it this far, congrats! The comprehension packs a lot of features into a tiny programming construct and demonstrating all of them is a lot of work! The comprehension is one of my favorite features of the Elixir programming language, and it was a pleasure to write about every feature in as much depth as I could. If you have any questions about comprehensions or want to suggest examples or features that I've missed, feel free to reach out on [Twitter](https://twitter.com/mitchhanberg) or [email](mailto:contact@mitchellhanberg.com). ## Supplementary Information ### List Comprehensions in Erlang It would be remiss to not mention that the list comprehension also exists in Erlang. I am not personally familiar with them, so I won't explain them very much, but I I'll provide an example and a link to learn more about them on your own. The following examples are from the official Erlang/OTP documentation and can be found [here](https://erlang.org/doc/programming_examples/list_comprehensions.html). ```erlang [X || X <- [1, 2, a, 3, 4, b, 5, 6], is_integer(X), X > 3]. % [4, 5, 6] [{X, Y} || X <- [1, 2, 3], Y <- [a, b]]. % [{1, a}, {1, b}, {2, a}, {2, b}, {3, a}, {3, b}] ```

Boost your test coverage with Elixir

Mon, 30 May 2022 08:53:43 GMT

From Bits of Code - Pieces of Writing: In this article, I will help you build the appropriate tooling to track and measure your test coverage, and hopefully improve it.

Code BEAM, Stockholm 2022

Sun, 29 May 2022 04:00:00 +0000

From Underjord.io: I started writing this on the train home from Code BEAM. It’s an Erlang, Elixir (and BEAM in general) conference put on by Code Sync which is part of Erlang Solutions. It was a hybrid conference, I was there entirely in person. It was a very good time. “Isn’t Underjord Just You?” Having gone recently from being a single-person consulting and contracting shop to having a small team I took a rather different approach to this conference.

LiveView on Nerves

Thu, 26 May 2022 04:00:00 +0000

From Underjord.io: I’ve played with Nerves for almost as long as I’ve been learning and using Elixir. Nerves is a fantastic way of working with hardware along with the BEAM virtual machine and it is great fun for hobbyist projects like Raspberry Pis. Phoenix LiveView is currently my favorite way of making full-stack web development cohesive and keeping the complexity as low as possible for it. I haven’t run into any short compelling demos of getting these started together.

Questions to Consider When Choosing a Software Development Consultant

Wed, 04 May 2022 00:00:39 +0000

From Binary Noggin:

The post Questions to Consider When Choosing a Software Development Consultant appeared first on Binary Noggin.

The Big Elixir 2022 - Building a Note taking App using LiveView, OTP, and friends - Mohammad Maqbool Alam

Sat, 30 Apr 2022 05:44:10 GMT

From ⚡ Maqbool Khan: In this talk, we will start by building the Backend while taking advantage of OTP primitives such as GenServer and friends to build a simple cron to fetch messages from Telegram API and then we build using Phoenix LiveView and Alpine.js to build the ...

Creating an Input Union Type System Directive in Absinthe

Thu, 28 Apr 2022 11:08:54 +0100

From Maarten van Vliet: In this post I will explain how to create a type system directive in Absinthe to implement Input Unions in Graphql. The code for this post can be found on Github A common issue with GraphQL is the lack of input unions. This means an input object that lets you choose between a number of potential input types. For example (taken from a spec discussion): input PetInput { cat: CatInput dog: DogInput fish: FishInput } input CatInput { name: String!

How EEx Turns Your Template Into HTML

Mon, 11 Apr 2022 01:00:00 -04

From Mitchell Hanberg's Blog: EEx is a templating language and module built into the [Elixir](https://hexdocs.pm/eex/EEx.html) standard library, often used by web servers to render dynamic content for a web application. The same concept exists in other language ecosystems, ERB for Ruby, Blade for Laravel/PHP, Pug/Jade for JavaScript. A couple features of EEx that make it stand out are: - Templates can be compiled into functions ahead of time, avoiding needing to read from the file system at runtime. - EEx has the concept of an "Engine" allowing you to compile an existing template into something different than what the builtin engine, [`EEx.SmartEngine`](https://hexdocs.pm/eex/EEx.SmartEngine.html), does. This is what [Phoenix LiveView](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html) does. Recently, [José Valim tweeted me some advice on how to use the EEx Engine](https://twitter.com/josevalim/status/1511348149323014155?s=20&t=sFyaicmJApbs5yQO-n_CIA) in my library [Temple](https://github.com/mhanberg/temple) (an alternative HTML library, that uses an Elixir DSL). At first I was very confused at José's suggestion; I don't want to write EEx at all! I want Temple to go from DSL straight to `iolist` or `%LiveView.Rendered{}` structs. Luckily, my coworker [Marlus Saraiva](https://twitter.com/MarlusSaraiva) messaged me and gave a bit more context on José's suggestion, and suddenly it all clicked!. (Hopefully at the end of this post, you'll understand how José's suggestion makes perfect sense and was extremely clear.) This conversation led me to ask myself, how does EEx work anyway? I decided to source dive EEx, LiveView, [Surface](https://surface-ui.org/), and [HEEx](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Helpers.html#sigil_H/2-syntax) and will share with you what I learned! ## The Source Code Technically EEx is just a templating syntax that can handle any plaintext format. It doesn't matter if its HTML, JavaScript, or even Elixir (this is how the Phoenix generators work). EEx templates allow you to execute arbitrary Elixir code inside of special tags and inject the runtime result into the return value. You can use single expressions or even expressions that take blocks. The `EEx.SmartEngine` also allows you to ergonomically access data passed to the template with the `@` syntax. ```eex <%= @user.name %>

<%= user.name %>

``` ## The Compiler The public API for compiling an EEx file or string consists of the `EEx.compile_file/2` and `EEx.compile_string/2` functions. Internally, they will call into the `EEx.Compiler` module. The `EEx.Compiler` module is where the coordination happens when compiling our source code. You can find the source code [here](https://github.com/elixir-lang/elixir/blob/v1.13.3/lib/eex/lib/eex/compiler.ex). This module's `compile/2` function is responsible for calling the tokenizer, traversing them, and passing them to the appropriate callbacks on the engine. By default, EEx uses the builtin `EEx.SmartEngine`. Essentially there are two steps: 1. Turn the source into tokens. 2. Turn the tokens into Elixir AST by passing them to the relevant callback on the given `EEx.Engine`. ## The Tokenizer The first thing that the compiler will do is tokenize the content. You can find the source code [here](https://github.com/elixir-lang/elixir/blob/v1.13.3/lib/eex/lib/eex/tokenizer.ex). This translates the source code into a list of Elixir terms that describe the tokens found in the document. The above example will be tokenized into the following. ```elixir {:ok, [ {:text, 0, 0, '\n'}, {:expr, 1, 7, '=', ' @user.name '}, {:text, 1, 24, '\n\n\n

'}, {:expr, 6, 9, '=', ' user.name '}, {:text, 6, 25, '

\n'}, {:eof, 9, 1} ]} ``` The list of tokens are fairly self explanatory. We can see `:text` tokens for static ranges of plain text, `:expr` tokens for single line expressions, and `:start_expr`/`:end_expr` tokens for the multi-line do/end block expression. The tokens also include some row/column metadata, which is helpful later on for attributing error messages to the origin point in the source code. Now that we have the tokens, we need to traverse over them and pass them into the engine. ## The Engine The engine is where the magic happens! It's responsible for building the tokens into usable Elixir AST, which can then be injected into a function. An `EEx.Engine` has the following callbacks that it must implement and that your compiler must call appropriately. I'll copy/paste some of the callback documentation here, copyright belonging to the elixir-lang/elixir project. ```elixir @doc """ Called at the beginning of every template. It must return the initial state. """ @callback init(opts :: keyword) :: state @doc """ Called at the end of every template. It must return Elixir's quoted expressions for the template. """ @callback handle_body(state) :: Macro.t() @doc """ Called for the text/static parts of a template. It must return the updated state. """ @callback handle_text(state, [line: pos_integer, column: pos_integer], text :: String.t()) :: state @doc """ Called for the dynamic/code parts of a template. The marker is what follows exactly after `<%`. For example, `<% foo %>` has an empty marker, but `<%= foo %>` has `"="` as marker. The allowed markers so far are: * `""` * `"="` * `"/"` * `"|"` Markers `"/"` and `"|"` are only for use in custom EEx engines and are not implemented by default. Using them without an appropriate implementation raises `EEx.SyntaxError`. It must return the updated state. """ @callback handle_expr(state, marker :: String.t(), expr :: Macro.t()) :: state @doc """ Invoked at the beginning of every nesting. It must return a new state that is used only inside the nesting. Once the nesting terminates, the current `state` is resumed. """ @callback handle_begin(state) :: state @doc """ Invokes at the end of a nesting. It must return Elixir's quoted expressions for the nesting. """ @callback handle_end(state) :: Macro.t() ``` The compiler will start by calling the `c:init` callback to initialize the engine's state. It will pass this state to the various other callbacks as required. The state is an implementation detail to the Engine but will usually collect the static and dynamic pieces of the template as it traverses the tokens. Whenever the compiler encounters a "text" token, it will pass the state, the metadata, and the text to he `c:handle_text/3` callback. Whenever the compiler encounters an `expression` token, it will pass the state, the "marker", and the expression AST to the `c:handle_expr/3` callback. If the encountered expression is multi-line, it will call the `c:handle_begin/3` callback. This creates a new "nesting" and will return a brand new state to be used to collect the output for the "nested" tokens. When the compiler encounters an `:eof` token, it knows the template has finished and passes the state to `c:handle_body`, which returns the Elixir AST for the entire template. I built an app that allows you to step through the compilation of a template as it traverses the tokens to help visualize what is happening and the output that is produced. ![EEx Compiler Visualizer](https://user-images.githubusercontent.com/5523984/162604950-a682e940-2af2-4968-886b-7413f256020d.gif) You should check it out [here](https://github.com/mhanberg/eex_compiler_visualizer). Here is what the compiled output for the above example looks like. The AST generated by the `EEx.SmartEngine` forms all dynamic parts of your template into variables, then at the end, creates a `bitstring` with the result. ```elixir arg0 = String.Chars.to_string(EEx.Engine.fetch_assign!(var!(assigns), :user).name) arg1 = String.Chars.to_string( for user <- EEx.Engine.fetch_assign!(var!(assigns), :users) do arg1 = String.Chars.to_string(user.name) <<"\n

", arg1::binary, "

\n ">> end ) <<"\n", arg0::binary, "\n\n\n

\n ", arg1::binary, "\n">> ``` Let's take a look at how the `Phoenix.HTML.Engine` compiles the same template. We can observe some similarities: it has the same `@` assigns functionality and it groups dynamic pieces into variables to coordinate later into the final result. It also packs in some extra features! - It will escape dynamically rendered plaintext, so you won't accidentally get some JS injection. - It can pass data through the `Phoenix.HTML.Safe` protocol, allowing you to make custom representation of your Elixir data structures. - It builds the result into `iodata` instead of a `bitstring`. ```elixir arg0 = case Phoenix.HTML.Engine.fetch_assign!(var!(assigns), :user).name do {:safe, data} -> data bin when is_binary(bin) -> Phoenix.HTML.Engine.html_escape(bin) other -> Phoenix.HTML.Safe.to_iodata(other) end arg1 = case (for user <- Phoenix.HTML.Engine.fetch_assign!(var!(assigns), :users) do arg1 = case user.name do {:safe, data} -> data bin when is_binary(bin) -> Phoenix.HTML.Engine.html_escape(bin) other -> Phoenix.HTML.Safe.to_iodata(other) end {:safe, ["\n

", arg1, "

\n "]} end) do {:safe, data} -> data bin when is_binary(bin) -> Phoenix.HTML.Engine.html_escape(bin) other -> Phoenix.HTML.Safe.to_iodata(other) end {:safe, [ "\n", arg0, "\n\n\n

\n ", arg1, "\n" ]} ``` Let's also peek at the output of `Phoenix.LiveView.Engine`, as it will generate something fairly different than the previous two engines. The LiveView engine will emit these `%Rendered{}` and `%Comprehension{}` structs that allow it to efficiently do its diff tracking. ```elixir require Phoenix.LiveView.Engine ( dynamic = fn track_changes? -> changed = case assigns do %{__changed__: changed} when track_changes? -> changed _ -> nil end ( v0 = case Phoenix.LiveView.Engine.nested_changed_assign?(assigns, changed, :user, struct: :name) do true -> Phoenix.LiveView.Engine.live_to_iodata(assigns.user.name) false -> nil end v2 = case Phoenix.LiveView.Engine.changed_assign?(changed, :users) do true -> %Phoenix.LiveView.Comprehension{ static: ["\n

", "

\n "], dynamics: for user <- assigns.users do v1 = Phoenix.LiveView.Engine.live_to_iodata(user.name) [v1] end, fingerprint: 245_710_792_584_248_035_419_893_716_549_685_965_177 } false -> nil end ) [v0, v2] end %Phoenix.LiveView.Rendered{ static: [ "\n", "\n\n\n

\n ", "\n" ], dynamic: dynamic, fingerprint: 104_434_365_286_405_865_087_616_174_532_871_347_220, root: nil } ) ``` ## How can this help Temple? So far we've detailed how _Elixir_ will compile an EEx template. The `EEx.Tokenizer` and `EEx.Compiler` are not public modules and are essentially an implementation detail. Surface and HEEx are not EEx compatible, so attempting to compile them with `EEx.compile_string/2` would raise a syntax error. So how do they work? They both implement their own tokenizer and compiler but delegate to the engine! Temple can do the exact same thing. The _Engine_ is the public API that Temple can leverage to efficiently output Elixir AST for the various compile targets: Non-Phoenix web apps (for use in Plug, [Aino](https://github.com/oestrich/aino), any non-Phoenix web framework), traditional Phoenix Apps, and Phoenix LiveView apps. This is the technique that José was explaining that HEEx and Surface use. Here is a table comparing which parts of the "template to Elixir AST" lifestyle between the builtin EEx compiler, the Temple compiler (in a theoretical future when Temple leverages this technique), Surface, and HEEx. EEx and HEEx don't have their own AST, so the parser step is not applicable. | Step | EEx | Temple | Surface | HEEx | | --- | --- | --- | --- | --- | | Tokenizer | EEx.Tokenizer | Kernel.SpecialForms.quote/2 | Surface.Compiler.Tokenizer | Phoenix.LiveView.HTMLTokenizer | | Parser | - | Temple.Parser | Surface.Compiler.Parser | - | | "Compiler" | EEx.Compiler | Temple.Renderer | Surface.Compiler.EExEngine | Phoenix.LiveView.HTMLEngine | | Engine | Chosen Engine | Chosen Engine | Phoenix.LiveView.Engine | Chosen Engine | Prior to this revelation, I had planned on the monumental task of basically re-implementing the `EEx.SmartEngine`, `Phoenix.HTML.Engine`, and `Phoenix.LiveView.Engine` modules in Temple (probably with lots of bugs). Now that I understand how to utilize the existing engines properly, it should be a relatively small lift for Temple to be able to use all three of them! 🎉 Kudos to José and Marlus for the advice, I really appreciate it!

Writing Shell Scripts Using Elixir

Mon, 11 Apr 2022 00:00:00 +0000

From My.Thoughts v1: Intro First of all, my apologies for not having written a blog post since July of last year! Between maintaining all my open source libraries, publishing Build a Weather Station with Elixir and Nerves, starting Elixir Patterns with Hugo Barauna, running my consulting business and being a host on the BEAM Radio podcast…something had to give and unfortunately it was my Elixir blog 😔. But alas, I have promised myself that I can (and will) write a new blog post every quarter as opposed to every month like I used to.

Fundamentals & Deployment

Mon, 21 Mar 2022 04:00:00 +0000

From Underjord.io: I’ve had Gerhard Lazu on my livestream once where he showed me a way of doing CI/CD with k3s and ArgoCD. The podcast Ship It! that he hosts on Changelog recently had Kelsey Hightower on. Kelsey is to many this guru of the cloud native and Kubernetes space. I’ve had good value from what I’ve heard him say in the past. In this episode he really spoke to me. So he essentially said, I’m interpreting here, that when it comes to deploying software to servers the documented manual steps for deploying something need to be the canonical reference.

Is LiveView Overhyped?

Thu, 17 Mar 2022 04:00:00 +0000

From Underjord.io: To alleviate any sense of clickbait. No, it is not overhyped as a technology, in my opinion. Let’s get into the nuances. In a recent tweet a while back a member of the Elixir community expressed some frustration with how everything is all about LiveView. It led to some interesting and useful discussion and as someone who writes a fair bit about Elixir, Phoenix and such I have thoughts. Following on that discussions other people expressed further concern about the unreserved enthusiasm with which some of us have pushed LiveView and maybe even more, the PETAL stack.

Nerves Quickstart

Fri, 04 Feb 2022 04:00:00 +0000

From Underjord.io: This is a labor of love where I just wanted the Nerves project to have a nice promo video. Frank and crew put a lot of work into making Nerves approachable while all their day-to-day use and needs is in the nitty-gritty industry side of it. So what does all that effort get them? Well, they’ve gotten it to the point where a complete step by step can be a one minute, 38 seconds long video.

Video - What Is: Elixir

Sun, 30 Jan 2022 04:00:00 +0000

From Underjord.io: Trying to put words to the technology that has been most important to me for the last 4-5 years. Elixir. A language I picked up and now work almost exclusively with and specialize in. It is not the mainstream and I think that has serious advantages. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Video - How Do: Server

Sun, 30 Jan 2022 03:00:00 +0000

From Underjord.io: This one has been a while at the back of my mind. A lot of my readers have mentioned wanting to learn Linux and servers. This is an attempt at just unleashing you on the very first steps of your journey to do server work. It covers setting up a server with Linode (taken as an example) and then installing a webserver on it. I also cover a few bits about securing a server and potential next steps.

Video - What Is: Server

Sun, 30 Jan 2022 02:00:00 +0000

From Underjord.io: A brief explanation of servers, the concept. Next step should be to show you good folks some stuff about how I set one up. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Original 720 low Sorry, your browser does not support embedded videos.

Formatting GraphQL in Elixir projects

Wed, 26 Jan 2022 11:08:54 +0100

From Maarten van Vliet: With the release of Elixir 1.13 it became possible to add plugins to the formatter. These plugins gives developers the option to hook into the Elixir formatter. I’ve created an Elixir formatter plugin to Absinthe to format GraphQL documents. With the release of Absinthe 1.7 this is available for everyone to use. To start, you’ll need Absinthe 1.7 or higher together with Elixir 1.13 or higher. The Absinthe project comes with Absinthe.

My Elm Experience

Thu, 20 Jan 2022 04:00:00 +0000

From Underjord.io: I’ve been using Elm since about one year back now. At the start of 2021 I began working with a client that had an existing Elm frontend code base and an early stage backend built in Elixir and Phoenix. This post will be about my experiences running face first into Elm. I’ll be vague on some details as I can’t share too much about the specific client and code base. I’ll be much less vague about Elm itself.

Video: Fixing my LiveView app

Fri, 07 Jan 2022 04:00:00 +0000

From Underjord.io: My note-taking web app build in LiveView needed some fixing. Also updated it to use the new heex templates. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Video: Indie Livestreaming with Elixir & Membrane

Tue, 21 Dec 2021 04:00:00 +0000

From Underjord.io: So Software Mansion, the makers of Membrane Framework, have kindly conspired with me to get RTMP ready for Membrane. RTMP is the protcol used when streaming from popular open source tool OBS. The RTMP module is currently at a technical preview level so be warned, might have some sharp edges. They made sure there was a chain of building blocks from RTMP to HLS (HTTP Live Streaming) and now I can actually set up a completely independent version of the Underjord livestreams.

Video: Building Out Indie Livestreaming with LiveView and Membrane

Tue, 21 Dec 2021 04:00:00 +0000

From Underjord.io: On a previous stream we tested out the library for RTMP in Membrane to achieve streaming on our own in Elixir. This time we make it more convenient, flexible and work our way towards using it. Being able to prepare and start livestreams, setting them up with LiveView, giving meaningful progress to users. Things are fun when you have near real-time events :) function switch_video(element) { var src = element.

Video: Improving a GenServer, My IoT Lightswitch

Tue, 21 Dec 2021 04:00:00 +0000

From Underjord.io: GenServer is the typical Actor abstraction in Erlang and Elixir. I’ve used one for talking to my Elgato Keylights in the lightswitch project. I made it sort of dumb. It was a quick job so I want to improve it in a few ways. Make it not need to pull the new state from lights before sending commands. Pull state in the background occasionally to keep relatively up-to-date. Always fetch status after sending commands.

Video: Elixir and Computer Vision with evision

Tue, 21 Dec 2021 04:00:00 +0000

From Underjord.io: From Twitter I stumbled on this neat, still early, but working project for using the OpenCV library from Elixir. So I decided to give it a whirl! The project is called evision and I had a great time on stream screwing around with it :) function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Guest post: Cross-cutting Elixir in Teams

Tue, 21 Dec 2021 04:00:00 +0000

From Underjord.io: Release day. Although the product team was used to a bit of a hustle to wrap up open features, perform final testing, and prepare for deployment, today presented some additional challenges. This morning Jerry, the team’s product manager, discovered that one of the major features slated for this release was implemented in a way that would cause problems for some key users on the platform. Jerry notified Mark, the backend engineer, who said he might be able to fix the issue by modifying the data sent to the frontend.

Winners - Manning book giveaway

Mon, 20 Dec 2021 04:00:00 +0000

From Underjord.io: Just a brief note announcing the three winners of the giveaway that take home a copy of Elixir in Action by Saša Jurić. Thanks to Manning for providing those copies. If you want 35% off of their books you can use the discount code nlunderjord21 and you can find their collection via this link that definitely will track some statistics about click-through rates (you have been warned): Manning’s other books.

Are you hiring Elixir developers?

Tue, 14 Dec 2021 12:00:00 +0000

From Underjord.io: Is your company actively trying to hire Elixir developers? Or should you be? I care about making good software happen. Even if I’m not writing it. And good software is formed from good teams. To help this happen I want to connect companies and developers in the Elixir space. I know and connect with plenty of both. This is the first time I mention this particular offer to the public. If the interest is at the level it seems this will also be the only chance to get in at the initial pricing.

Are Contexts a Thing?

Mon, 06 Dec 2021 04:00:00 +0000

From Underjord.io: The discussion of Contexts in Phoenix and their general usefulness feels like a common point of disagreement in Elixir. I’ve gathered that the discussions went high and low as it was becoming a thing in mainline Phoenix. I don’t really care for controversy but what I see is a topic which gets confusing to wrangle with and which I never know quite how to explain. So this will be an attempt to explain what Contexts as provided are, cover some common concerns around this and two rather opposing suggestions about how to deal with them.

Books

Thu, 02 Dec 2021 16:56:55 -0400

From My.Thoughts v1: If you enjoy reading my blog posts, using my open source libraries, and my Elixir tips, be sure to checkout my book publications and show your support. It means a lot to me and I am sure you’ll learn something cool from my books :). Build a Weather Station with Elixir and Nerves In this book, Bruce Tate, Frank Hunleth and I discuss how to build and program a Nerves based weather station.

Giveaway: Elixir in Action

Tue, 23 Nov 2021 04:00:00 +0000

From Underjord.io: The book Elixir in Action by Saša Jurić is widely recognized as one of the best books on this language I favor. I’ve been meaning to run some giveaways and this book was always on the agenda. It shouldn’t be the only one but I think it makes a very appropriate starting point. Especially as the book has been such a starting point for many Elixirists through the years. Transparency note: This giveaway is supported by Manning, the publisher that published Elixir in Action.

Building a Startup on Elixir to a $50 mil round

Wed, 17 Nov 2021 06:00:00 +0000

From Underjord.io: I became familiar with Marcin Kulik when I was brought in to work with a company called Vic.ai. A fintech startup. Marcin is the guy who started building their entire Elixir system and was the person to primarily onboard me to the work. When I was brought in they were a small team of 4 devs, looking to grow up to around 7 at the time. Special thanks to DockYard for supporting my work on this piece.

Finally using your Raspberry Pi & Elixir

Sat, 30 Oct 2021 12:00:00 +0000

From Underjord.io: How many Raspberry Pi do you have sitting in a drawer. I think I still have about 4? And at least 2 on a shelf. I may be over the average there but the story itself is common. “Oh! This is neat, I can automate X with this! And learn Y tech doing it!” And yet it never gets quite done. For reasons. No one needs to feel too bad about this.

Video: Attempting to Control Elgato Keylights from Nerves

Sun, 24 Oct 2021 04:00:00 +0000

From Underjord.io: This livestream we tried to control my Elgato Keylights from a Nerves device. We really tried gang, come on. A good attempt. We ran into an issue with the expectations we had on what mDNS would give us. Those issues are still under investigation but they seem to be a change or regression in underlying parts of Nerves or Erlang. I’ve since gotten it to work by going back a few versions.

Video: Automatically Clustering Nerves devices

Fri, 22 Oct 2021 04:00:00 +0000

From Underjord.io: Sitting down to show some of the work I’ve done with Nerves and Erlang Distribution for clustering Raspberry Pis. In this case automatically, via mDNS. This is what I do when I have a cold and am not streaming I guess. We also poke around with an HDMI screen on the Pi400. I want to run Scenic on that one. function switch_video(element) { var src = element.getAttribute("href"); var video = element.

Video: Making a Calendar Gadget with Nerves and LiveView

Fri, 15 Oct 2021 04:00:00 +0000

From Underjord.io: Cleaning up previous work and making the eInk display look fabulous by iterating in our LiveView-based simulator. We get this thing ready for small office production :) function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Absinthe subscriptions-transport-ws websocket

Sat, 02 Oct 2021 12:04:18 +0200

From Maarten van Vliet: Absinthe subscriptions-transport-ws websocket Support subscriptions-transport-ws websocket protocol for Absinthe https://github.com/maartenvanvliet/subscriptions-transport-ws

Video: Forming an Erlang cluster of Pi Zeros

Thu, 30 Sep 2021 04:00:00 +0000

From Underjord.io: I sat down with the stream and gently coaxed a couple of Raspberry Pi Zeros to cluster up with each other using the Nerves project. With recent support for Erlang distribution in MdnsLite we got the power to help nodes find each other via mDNS instead of some other method. So I wanted to give it a whirl, and I did :) Special thanks to Isaac for his help in the chat.

Video: Unbox a Pi400 and put Nerves on it

Mon, 20 Sep 2021 04:00:00 +0000

From Underjord.io: I’ve been enjoying some Nerves recently which prompted me to finally order the Pi400 to play around with. In this stream I unpack it and get Nerves running on it without having tried it before or hearing that anyone had tried it. I just trusted the hard work of the Nerves team. Turns out that was a great call. It worked beautifully, almost confusingly well. Then we investigated some of the things we can do with a Pi with input devices but no output connected.

Video: Nerves, Livebook & small displays (eInk, OLED)

Thu, 16 Sep 2021 04:00:00 +0000

From Underjord.io: The Inky eInk display was one of my first real things done with Elixir. And I’m apparently back on my bullshit. Because I just pulled that thing out and tried it with Nerves + Livebook. Had a really good time this stream and I think I want to do more things with hardware like this. Let me know if you’d be curious to see more of this. This triggered a not-yet-working Nerves device project I’m calling my calendar gadget which will be more documented at some point I’m sure.

Video: Phoenix 1.6 RC, Preview

Fri, 03 Sep 2021 04:00:00 +0000

From Underjord.io: There are some very exciting updates in Phoenix 1.6 that just recently hit RC. We go through and try them out. It all seems to work great. I consider every bit of it an improvement. The official blog announcement for RC 0 has the details and I reference it through the video. I particularly tried out the LiveView Heex template changes which was great. This seems much more ergonomic and it wasn’t bad to begin with at eex/leex.

Video: Elixir & Ecto, generating queries

Fri, 27 Aug 2021 04:00:00 +0000

From Underjord.io: As part of some foundational work on a CMS concept I’ve been building out this fairly dynamic Ecto-based way of dealing with content types and content (we call it entity types and entities) in a database. And I wanted this to be broadly compatible. That’s what most of this livestream ended up being about from what I remember. Trying things and swearing about internals. All in all a good time right?

Video Companion - Teaching Elixir - Strings

Mon, 23 Aug 2021 04:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time, strings. You can find the livebooks of the modified lessons in my fork of ElixirSchool. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Video: Elixir CMS Thoughts, and code

Mon, 23 Aug 2021 04:00:00 +0000

From Underjord.io: I’ve had a lot of thoughts and a few failed runs at creating a CMS in Elixir. This isn’t because Elixir is particular hard to do it in. Rather the opposite. The reason I’ve abandoned those efforts have to do with what exactly I want solved with a CMS. I’ve outlined some of that in The WordPress merging problem and WordPress & the gross inefficiencies. I’m trying to create a sound technical solution with a sound human solution on top of it.

Video Companion - Teaching Elixir - Comprehensions

Mon, 16 Aug 2021 04:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time, comprehensions, the most arcane. You can find the livebooks of the modified lessons in my fork of ElixirSchool. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Video: Attempting Operational Transformation .. again

Mon, 16 Aug 2021 04:00:00 +0000

From Underjord.io: Getting deeper and farther into trying to do Operational Transformation with Erlang wxStyledTextCtrl, aka. Scintilla and TextDelta. I end up doing almost no TextDelta or Operational Transformation in this one as I try to pin down whether I can reliably insert and delete text from the different editor sessions without causing endless loops of updates. Turns out that there is no great facility for handling that. We learn quite a bit.

Video Companion - Teaching Elixir - Sigils

Fri, 13 Aug 2021 04:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time, sigils, the most arcane. You can find the livebooks of the modified lessons in my fork of ElixirSchool. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Video: Attempting Operational Transformation

Fri, 13 Aug 2021 04:00:00 +0000

From Underjord.io: In an act of hubris I try to tackle with wxStyledTextCtrl and Operational Transformation in an unholy alliance of native UI and offline-friendly collaboration. I get partway there but nothing actually works. Hopefully the flailing is interesting :) function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

Video Companion - Teaching Elixir - Modules

Thu, 05 Aug 2021 04:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover modules. You can find the livebooks of the modified lessons in my fork of ElixirSchool. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

It is not about Elixir

Fri, 30 Jul 2021 04:00:00 +0000

From Underjord.io: That’s right. It never has been. Before you read this post with your teeth clenched and ready for some hot takes, chill. This isn’t where I throw Elixir under the bus. Rather it is where I try to put my finger on the values that makes Elixir a good fit for me and a language I consistently recommend to people. So to summarize the values: Software should be efficient Software should be maintainable Software should be suitable for continuous development Developers should not burn out from the work Teams should be able to deliver consistently without stress Technically conservative but extremely progressive So some of my values are fairly specific to software though they apply in other contexts as well.

Video: Building with PETAL 4 - Authentication

Thu, 29 Jul 2021 04:00:00 +0000

From Underjord.io: In this stream of the PETAL Photo project we work on authentication. We build a way to log in with a magic link through email. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 low Sorry, your browser does not support embedded videos.

GenServer from first principles: Mohammad Maqbool Alam // Elixir Wizards Conference 2021

Tue, 20 Jul 2021 03:42:18 GMT

From ⚡ Maqbool Khan: GenServer from first principles: Maqbool Alam // Elixir Wizards Conference 2021

Video: Building with PETAL 3 - Thumbnails and Transcoding

Fri, 16 Jul 2021 04:00:00 +0000

From Underjord.io: Getting a bit technical in this one we get into thumbnails and video transcoding in the middle of a heatwave. Watch me sweat .. the details with FFMPEG. This is the third installment Part 2 and Part 1. I don’t think they are necessary context but it probably helps. There has also been a few hours of work before each stream so the system moves forward off screen a bit.

Video: Building with PETAL 2 - Mostly Tailwind

Fri, 16 Jul 2021 04:00:00 +0000

From Underjord.io: It continues. After some off-stream work fixing the upload issues from last stream we are now mostly heading into making this visually sensible. We are using the PETAL stack and that means a lot of Tailwind CSS. This is the second installment, consider watching Part 1 before or after this. So if you enjoy watching people turn blank white nothing into something more visual, this might be for you, or if you want to see someone that is not a Tailwind expert wield it, also accurate.

Video: Building with PETAL 1 - Getting Started

Fri, 16 Jul 2021 04:00:00 +0000

From Underjord.io: It begins. For my vacation work-days, a concept to explain soon, I wanted to try to scratch an itch that I feel have product potential. So I decided to do parts of the work on the stream. This is the first part. To address the vacation work-days thing. I’m not being terrible at vacationing, or at least not as far as I can tell. We have a young child in the house, so some time on my own is quite nice and I have established some routines I really enjoy that I didn’t want a break from this summer staycation.

The Human Side of Elixir

Mon, 12 Jul 2021 00:00:00 +0000

From My.Thoughts v1: Intro If you follow my blog, you have probably noticed that my articles usually revolve around some deep technical problems and how to go about solving these problems using the amazing Elixir programming language. These posts usually discuss the technical merits surrounding Elixir and the Erlang virtual machine, but rarely touch on the “human” aspects of Elixir. The goal of today’s post will be to address some of the non-technical aspects of the Elixir programming language and talk about the profound impact they can have on your engineers and your business.

Trust in Software, an All Time Low

Fri, 09 Jul 2021 04:00:00 +0000

From Underjord.io: I don’t think I’ve ever had more distrust and as a consequence distate for software than in recent years. I don’t think its just me as a tech-nerd with artisanal tech-carpentry aspirations. I want people to build well, treat their users right and generally exercise some actual restraint. I see it very clearly and I react more viscerally than anyone non-technical in my surroundings. However, I see the frustrations and the consequences everywhere.

Teaching Elixir

Tue, 06 Jul 2021 08:34:25 +0300

From Posts on Claudio Ortolina:

When I joined PSPDFKit in 2018, I inherited the development and maintenance of PSPDFKit Server, the server-side component of PSPDFKit for Web.

Initially, I was the only person working on the project full-time. The team eventually expanded to a total of three people and I moved on to manage the Web Team.

In addition, other developers occasionally contributed features with differing degrees of complexity (ranging from small, incremental changes to large features over a few weeks of work).

Looking at the entire process, I can safely say that onboarding has been smooth and fast, especially for internal hires from different teams.

There are, of course, lessons learnt from this process, which is exactly what this blog post is about.

This post was sponsored by digital product consultancy DockYard to support the Elixir community and to encourage its members to share their stories.

The organization

PSPDFKit is a distributed company where everyone works remotely. The PSPDFKit Server team includes people with overlapping time zones and no fixed working hours.

The core business for the company is the sale of SDKs used to manipulate documents (predominantly in PDF format).

SDKs support a variety of platforms (iOS, Android, Windows, and web) and are embedded in client applications written and maintained by our customers.

The Project

PSPDFKit Server’s codebase is more than five years old and has grown organically over time thanks to the work of people with different expertise and backgrounds.

Domain-wise, the application manages the lifetime of a document, allowing our customers to build specific workflows on top of a small set of primitives: documents, content layers, annotations of different types, and permission sets. At a very high level, a user can open a document, perform an arbitrary set of actions (with the option of leveraging real-time collaboration with other users), and finish their session with changes automatically and efficiently stored.

Due to the way the product is sold and operated, it has a few key properties that make it different from most projects I’ve ever worked on:

It’s both CPU and memory intensive due to the amount of operations performed on PDF files. The component that interacts with PDF files is run as a binary daemon and maintained by a different team.
The application has optional components that are activated depending on specific configuration options. For example, one can enable an entire caching layer based on Redis.
Features can be turned on and off remotely via our licensing infrastructure.
The release is shipped as a Docker image to be operated on premise by the customer. This property has two implications. First, it means that we don’t have direct access to performance monitoring or visibility over runtime issues. Second, it drives us to minimise the operational complexity of the end product; for example, we don’t leverage the native Erlang/Elixir distribution because that would complicate deployment for our customers.

Onboarding results

In the last two years, we managed to onboard a good number of people:

1 external hire with extensive Elixir experience, now part of the team full time
1 internal hire with no Elixir experience, now part of the team full time
2 internal hires with no Elixir experience, in the process of joining the team full time
1 person contributing a significant piece of work over a few weeks
Occasional contributions by other people

It’s great that we can facilitate different degrees of contribution, with a ramp-up time measure between a couple of days and a week.

The people involved have completely different backgrounds: heavy frontend development, systems programming, and mobile development. Furthermore, apart from one person, everyone had very little functional programming experience.

Training structure

Learning styles

An important aspect to consider is each person’s learning style. Some people prefer pair-programming, while others would rather go through tutorials in their own time and ask questions when needed.

To accommodate such differences, we combine learning materials with targeted pairing sessions as well as follow-up calls to clarify where needed. We also keep the schedule pretty flexible, meaning that we don’t have a fixed curriculum people go through in a set period of time.

Tooling

The company uses a diverse set of languages and associated development tools. This ranges from text editors to full-fledged IDEs, as well as running on MacOS, Windows, and Linux.

Apart from work on platforms where there’s strong incentive to standardize on a specific tool (e.g. XCode for iOS development), people pick their tools based on personal preference.

A quick informal survey of the Server Team reveals that people predominantly use MacOS and favor Vim, Emacs, VSCode, and JetBrains IntelliJ.

We enforce code formatting at the CI level, but encourage people to set up their development environment to format on file save.

For code intelligence, Elixir has a solid implementation of a Language Server that provides intelligent autocompletion, inline docs, and jump to definition. Especially for people coming from a Java background, this type of tooling helps provide a consistent experience.

In terms of domain-specific tooling, we glue everything together with shell scripts and Docker-based workflows.

Productivity ramp-up time

People are usually productive in two to three days, where “being productive” means being able to set up the project, getting a basic understanding of its structure and architecture, taking on a small piece of work, and producing a relevant pull request containing implementation, tests, and documentation.

You may have heard the mantra “Make a commit on your first day.” While I agree with the sentiment behind it, I find it puts too much pressure on the contributor.

As part of the initial onboarding, it’s normal to find little issues with setup scripts (e.g. things that stop working between major OS versions) or unclear documentation. In most cases, fixes are cheap to implement and offer an opportunity to discuss the application architecture.

Proficiency

On average, it takes two to three months for an engineer to become a proficient contributor who has worked on most areas of the codebase, including some of the internal parts which are subject to very low churn over time.

Learning materials

We generally recommend going through the Elixir Lang guides: they’re well written, accurate, and split in easy-to-digest chunks.

For all libraries, making package documentation available on hexdocs tends to be sufficient.

While we do have a few books available in the company digital library, they’re rarely consulted.

Scope

We start with small, incremental features, as they have a very high completion success rate. For internal hires, we try to choose something connected to a use case the person is already familiar with from previous work.

A more experienced team member is available for general guidance, so that the resulting piece of work includes all necessary components: implementation, tests, and documentation.

On a technical level, we try to avoid pieces of work that introduce more than one key concept. For example, if the person is not familiar with immutable data structures, we avoid assigning a feature that would also introduce concurrency patterns.

Example projects

There are cases where it’s worth starting from smaller, separate projects. For concurrency and distribution, it’s better to rely on smaller applications (e.g. the examples referenced in the Elixir Lang guides) to nail the basics.

Once the basics are clear, we build up by looking at codebase components to address topics like error handling, logging, production hardening, and recovery.

Learning is complemented by specific articles (e.g. an introduction to circuit breakers).

Providing feedback

When a person starts to submit code for review, we try to provide different layers of feedback:

At first, we focus only on functionality, so that things work as expected. At this stage, the purpose is to build confidence and get the person comfortable.
We address code quality and language conventions in follow-up PRs, so that changes can be reviewed separately and it’s clearer why they’re necessary.
Reviews include links for self-learning, so that the person can explore on their own.
If a PR review becomes too long, we suggest a pairing session to discuss things directly.
We try to use proper names for all concepts, but also be conservative about introducing too many ideas in the same feedback session.
We make a clear distinction between company and community conventions, as they may differ. This way, when the developer reads other code on their own, they can compare and contrast approaches. This also often provides constructive criticism on the way we do things.
We slow down as needed during pairing sessions focused on learning. We allow ourselves to diverge from the initial session goal if the person wants to drill into a different topic. Maintaining interest and enthusiasm is more important in the early stages than sticking to a predefined plan.
We recently started recording short videos that document how to approach specific development tasks in order to facilitate independent learning.

Milestones

Every person that learned Elixir in the company followed a different process, but it’s possible to identify common milestones.

Pattern matching and control flow

Understanding pattern-matching comes in the first hour of reading existing code. It takes more time to develop a sensibility around specifics, such as when to use a single function head with an internal case statement versus multiple function heads with specific pattern matching clauses.

Immutable data and functions

For people who approach Elixir as their first functional language coming from object-oriented languages, the first adaptation step is to start reasoning in terms of data passed through functions.

Our trainees quickly embraced immutability due perceived benefits in clarity and predictability of the program. For example, one of our engineers commented that at the beginning of his learning journey, he could sprinkle print statements all over the codebase to see values changing and visualize the application flow.

In this phase, developers tended to write very explicit code, with plenty of intermediate bindings and little use of more advanced language features like the |> operator or the with special form.

Configuration

Configuration usually triggers a few questions:

Should this value be configurable?
What about changing the value at runtime?
How does configuration interact with building a Docker image and, later on, the container runtime?

This is usually a good opportunity to introduce compile-time vs. runtime configuration, along with the operational implications of relying on the Application.* functions to get and set configuration values at runtime.

Common issues include hitting some light race conditions, namely unexpected test results due to configuration values being changed non-deterministically. It’s a great opportunity to reinforce that we should strive to write deterministic code that reads configuration as early as possible and passes relevant values down the line.

Concurrency and OTP

The application has a few concurrent components, but their structure is rarely modified and developers can use public APIs without much concern for the internals.

This is a big advantage and it lets us plan when to look at the concurrency model. We normally suggest looking at the examples in the Elixir Lang guides, then scheduling a couple of pairing sessions to look at the most significant components included in our codebase.

Once we’re done with the fundamentals, we approach concurrency patterns: pools, worker queues, tasks, etc. For such cases, we train only on our application codebase.

State management

The application depends on a few stateful components: metadata store, assets store, and different layers of caching (both filesystem and memory).

These components provide the opportunity to introduce ETS tables, process lifetimes and recovery patterns, OTP guarantees around process trees, and error-handling logic.

Metaprogramming

We found very little use for meta-programming, so we don’t make it an explicit part of the onboarding process. Most of the time, people look into it by themselves when they start exploring the internals of dependencies like Phoenix and Ecto.

Bumps on the road

What follows is a list of road bumps we encountered over time. Some of them are more tied to our application and the way we ship it, so they don’t necessarily represent issues with the language or the platform.

Dialyzer

Especially for people with knowledge of programming languages with static types, having Dialyzer as a separate step from the compiler can be frustrating.

Fortunately, the aforementioned Language Server and related projects make it possible to set up the editing environment to provide almost real-time type information with a reasonable level of accuracy.

Structuring large components

One common observation is that compared to other languages, Elixir applications are built on very few architectural patterns. This applies to both ours and others I’ve worked on in the past few years, and is especially noticeable outside concurrency-related areas (which very often implement explicit behaviours).

Most of the time, we simply take care of separating modules that perform side effects (e.g. writing/reading files, http calls, database interaction) from modules which only manipulate data.

Modules are grouped according to their main “topic,” which helps exploration.

Having fewer patterns sometimes makes the conversation slightly more difficult, as you need to develop a shared, domain-specific vocabulary to quickly express more complex ideas. On the plus side, the effort of defining names helps onboarding immensely, because it forces everyone in the team to be precise and thorough in their explanations.

Error handling and recovery

As we don’t operate the software we write, we need to take extra care with error handling. As best we can, we want to provide error messages that are simple(r) to understand for our customers (who are not Elixir developers).

This creates a very mild tension between our style of error handling and the literature and community examples around applications being run directly by the developers who write them.

For example, it’s much better for us to produce a single line error log with a specific name we understand compared to a more verbose stack trace, because it facilitates communication with the customer.

Conclusion

I often hear the argument, “it’s difficult to hire Elixir developers.” In my experience, once you have two reasonably knowledgeable engineers, you can stop searching for already-trained developers and expand the search to developers willing to learn the language. With some care around the onboarding process, it’s possible to successfully train a new developer every two to three months with a very reasonable impact on the rest of the team.

Thanks to Susan Watkins for editing this article

Deploying with k3s and ArgoCD

Thu, 01 Jul 2021 10:00:00 +0000

From Underjord.io: I’m pretty skeptical of Kubernetes as a choice for small teams, small projects and any less complicated operation. Gerhard Lazu is quite enthusiastic about it on the other hand. After having me on his show Ship It!, a Changelog.com production, I expressed some curiosity about k3s, a lightweight variant of k8s. He offered to come on the livestream and show me how good life can be. Hope you enjoy the video.

Video Companion - Teaching Elixir - Pipe Operator

Thu, 01 Jul 2021 04:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover the pipe operator |>. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. The video is also available on YouTube. function switch_video(element) { var src = element.

Systems Design & Architecture livestream

Thu, 01 Jul 2021 04:00:00 +0000

From Underjord.io: For this livestream I sat down with pen and (i)Pad and tried to hash out some of my design thinking for a product idea I’ve been turning over in my head. Let me know if this type of thinky-talky streams are of interest and I just might do some more of them. The video is also on the YouTube channel if you prefer. function switch_video(element) { var src = element.

An Elixir Adoption Success Story

Tue, 22 Jun 2021 19:51:56 GMT

From The Great Code Adventure: How a team that was new to Elixir over-delivered a big project in just three months.

Onboarding to Elixir

Tue, 22 Jun 2021 05:00:00 +0000

From Underjord.io: I’ve worked with a number of clients on Elixir projects and I’ve onboarded myself, I’ve been onboarded and I’ve onboarded others. And compared to my experiences with PHP/Python/Javascript and my limited experience with C#/.Net I have experienced quite a difference. Elixir projects tend to be very consistently laid out. Especially Phoenix-based web projects. The basic Phoenix generators provide a fair number of opinions on where things go. Even without that the general shape of an Elixir project is surprisingly stable.

Video companion - Teaching Elixir - Functions

Tue, 15 Jun 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover functions. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. The video is also available on YouTube. Sorry, your browser doesn't support embedded videos. If you enjoy this or have questions you can reach me via email as lars@underjord.

Video - Setting up Prometheus and Grafana with Elixir

Mon, 07 Jun 2021 10:00:00 +0000

From Underjord.io: Alex Koutmos, creator of the PromEx library and buddy from the radio show gave us some of his time to help set up Grafana and Prometheus metrics for our application Noted. This was an extremely tight path to a lot of observability. PromEx is very kind to you as a developer. Leveraging the common telemetry API to make something really compelling. And then Alex has spent the effort so you get a whole bunch of useful default dashboards rather than needing to decide up front what you want.

Video companion - Teaching Elixir - Control Structures

Mon, 07 Jun 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover control structures. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. The video is also available on YouTube. Sorry, your browser doesn't support embedded videos. If you enjoy this or have questions you can reach me via email as lars@underjord.

How I Handle Static Assets in my Phoenix apps

Mon, 07 Jun 2021 01:00:00 -04

From Mitchell Hanberg's Blog: I no longer use [Webpack](https://webpack.js.org/). Now I use [esbuild](https://esbuild.github.io/), [postcss-cli](https://github.com/postcss/postcss-cli), and [cpx](https://github.com/mysticatea/cpx). - esbuild bundles and transpiles my JavaScript files extremely fast. - postcss-cli processes my CSS and can run the [TailwindCSS JIT](https://tailwindcss.com/docs/just-in-time-mode) mode without any problems. - cpx copies other static files from the `assets` directory into the `priv` directory. Running each of these tools in development is just as easy as running Webpack. ```elixir # config/dev.exs esbuild = Path.expand("../assets/node_modules/.bin/esbuild", __DIR__) config :my_app, MyAppWeb.Endpoint, http: [port: 4000], debug_errors: true, code_reloader: true, check_origin: false, watchers: [ "#{esbuild}": [ "./js/app.js", "--target=es2015", "--bundle", "--outdir=../priv/static/js", "--sourcemap", "--watch", cd: Path.expand("../assets", __DIR__) ], node: [ "./node_modules/.bin/postcss", "./css/app.css", "--dir", "../priv/static/css", "-w", cd: Path.expand("../assets", __DIR__), env: [{"NODE_ENV", "development"}, {"TAILWIND_MODE", "watch"}] ], node: [ "./node_modules/.bin/cpx", "'static/**/*'", "../priv/static", "--watch", cd: Path.expand("../assets", __DIR__) ] ] ``` ## esbuild ![esbuild home page](https://res.cloudinary.com/mhanberg/image/upload/v1622864248/Screen_Shot_2021-06-04_at_11.36.48_PM.png) esbuild is part of the newest generation of JavaScript tooling. It is built in [Go](https://golang.org/) and is _extremely_ fast. All I really need is my JavaScript to be bundled and transpiled to some degree, and esbuild does just that. Since esbuild is not available in our path, we'll have to declare our watcher with the absolute path to the binary. To make this legible, I have pulled out the absolute path to a variable so it reads more like what we are used to. ## PostCSS Since I'm are no longer using Webpack, I just use the `postcss-cli`. The third highlighted line demonstrates that this configuration is really just a declarative way to run commands with [`System.cmd/3`](https://hexdocs.pm/elixir/System.html#cmd/2). This means I can use all the same options! I am using the new [TailwindCSS JIT](https://tailwindcss.com/docs/just-in-time-mode), which requires a couple of environment variables to be set, so I pass the `:env` option to include variables in the environment of PostCSS. ## cpx Once I ditched Webpack, I realized that in addition to bundling my JS and CSS, it was responsible for copying my other static assets to the `priv` directory. Luckily there is this handy npm package called `cpx` that will watch a glob of directories and copy them somewhere else when it notices changes. ## Wrapping Up The speed increase from switching from Webpack to esbuild is well worth the effort to make the switch. Do you use something other than Webpack in your Phoenix applications? Let me know on [Twitter](https://twitter.com/mitchhanberg)!

Video - Improving the crawler

Fri, 04 Jun 2021 06:00:00 +0000

From Underjord.io: A good jam session on improving the crawler. A bunch of basic ETS usage, some bug hunting and fixing and in the end I think it is better than it was :) The project repo I built up during the stream is on Github as lawik/caterpillar and the video is below. Also available on the YouTube channel. Sorry, your browser doesn't support embedded videos. Enjoy the things I do?

How to Set Up Neovim for Elixir Development

Wed, 02 Jun 2021 09:00:00 -04

From Mitchell Hanberg's Blog: > [!IMPORTANT] Update > 4/12/22: I've started working on a dedicated Neovim plugin for Elixir called [elixir-tools.nvim](https://github.com/elixir-tools/elixir-tools.nvim). Please follow me on [Twitter](https://twitter.com/mitchhanberg) for more frequent updates! This article is the spiritual successor to [How to use Elixir LS with Vim](/post/2018/10/18/how-to-use-elixir-ls-with-vim/). Since then, I've switched from Vim to the nightly release of [Neovim](https://github.com/neovim/neovim) as well as how I integrate linters, formatters, and LSPs. This article will cover: - Installing Neovim - Getting started with the builtin LSP client - Setting up Elixir LS - Integrating [Credo](https://github.com/rrrene/credo) _If you run into any problems with this guide, feel free to shoot me an [email](mailto:contact@mitchellhanberg.com)._ Let's get started! ## Installing Neovim You can install Neovim with your package manager of choice, or [asdf](https://asdf-vm.com). ### Homebrew ```shell $ brew install neovim ``` ### asdf ```shell $ asdf plugin add neovim $ asdf install neovim stable ``` ### Nightly > With the release of 0.5, you no longer need to use Neovim nightly for this setup. I will leave these instructions in case you still want to live on the edge. As of this writing, the builtin LSP client is only available on the nightly build of Neovim. Once 0.5 is released, you should be able to switch to a stable build, but for now, let's get nightly installed. My preferred method for managing my installation of Neovim is to use [asdf](https://asdf-vm.com). You can install it with [Homebrew](https://brew.sh) as well, but I find asdf to be better. For this article, I am going to assume you already have asdf installed, as it is the most prevalent way to manage Elixir and Erlang installations. But we still need to install the Neovim asdf plugin. ```shell $ asdf plugin add neovim ``` Listing the available versions demonstrates that we can install any previously released version of Neovim, as well as the nightly build. These versions are pre-built and downloaded as a GitHub release artifact. This makes installing them very fast. ```shell $ asdf list all neovim 0.1.0 0.1.1 0.1.2 0.1.3 0.1.4 0.1.5 0.1.6 0.1.7 0.2.0 0.2.1 0.2.2 0.3.0 0.3.1 0.3.2 0.3.3 0.3.4 0.3.5 0.3.6 0.3.7 0.3.8 0.4.0 0.4.1 0.4.2 0.4.3 0.4.4 nightly stable ``` If for some reason the nightly build cron job is on the fritz (as it sometimes is), you can also build form source with: ```shell $ asdf install neovim ref:master ``` What we are going to stick with is: ```shell $ asdf install neovim nightly $ asdf global neovim nightly ``` Now, if you want to _update_ your nightly installation, all you have to do is uninstall and reinstall. I use the following as a convenient shell alias. ```shell $ alias update-nvim-nightly='asdf uninstall neovim nightly && asdf install neovim nightly' ``` So, just to tie this all together, these are the steps you will go through to get Neovim nightly installed. ```shell $ asdf plugin add neovim $ asdf install neovim nightly $ asdf global neovim nightly $ echo "alias update-nvim-nightly='asdf uninstall neovim nightly && asdf install neovim nightly'" >> .zshrc # bash/fish/etc ``` ## Getting started with the builtin LSP client To help users get started with the LSP client, the Neovim team provides a plugin called [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig) that contains configurations for many common language servers. There are also a few other plugins revolving around autocomplete that you'll need to install to get the full LSP experience. With your preferred plugin manager, install the following plugins. I'm using [packer.nvim](https://github.com/wbthomason/packer.nvim). If you don't use a package manager, I suggest learning more about them by checking out packer.nvim as well as [vim-plug](https://github.com/junegunn/vim-plug). ```lua vim.cmd [[packadd packer.nvim]] local startup = require("packer").startup startup(function(use) -- language server configurations use "neovim/nvim-lspconfig" -- autocomplete and snippets use("hrsh7th/nvim-cmp") use("hrsh7th/cmp-nvim-lsp") use("hrsh7th/cmp-vsnip") use("hrsh7th/vim-vsnip") use("onsails/lspkind-nvim") end) ``` Now that we have the required plugins installed, let's set them up so they get booted when we start Neovim. I am using the `init.lua` config file, but you can also add this to your `init.vim` if you use a lua heredoc. ```lua local lspconfig = require("lspconfig") -- Neovim doesn't support snippets out of the box, so we need to mutate the -- capabilities we send to the language server to let them know we want snippets. local capabilities = vim.lsp.protocol.make_client_capabilities() capabilities.textDocument.completion.completionItem.snippetSupport = true -- Setup our autocompletion. These configuration options are the default ones -- copied out of the documentation. local cmp = require("cmp") cmp.setup({ snippet = { expand = function(args) -- For `vsnip` user. vim.fn["vsnip#anonymous"](args.body) end, }, mapping = { [""] = cmp.mapping.scroll_docs(-4), [""] = cmp.mapping.scroll_docs(4), [""] = cmp.mapping.complete(), [""] = cmp.mapping.close(), [""] = cmp.mapping.confirm({ select = true }), }, sources = { { name = "nvim_lsp" }, { name = "vsnip" }, }, formatting = { format = require("lspkind").cmp_format({ with_text = true, menu = { nvim_lsp = "[LSP]", }, }), }, }) ``` That should be it for the basic LSP client configuration. ## Setting up Elixir LS [Elixir LS](https://github.com/elixir-lsp/elixir-ls) is a tool that needs to be compiled from source, but it's pretty simple. Pick a directory to install and run the following commands. ```shell $ git clone git@github.com:elixir-lsp/elixir-ls.git $ cd elixir-ls && mkdir rel # checkout the latest release if you'd like $ git checkout tags/v0.7.0 $ mix deps.get && mix compile $ mix elixir_ls.release -o release ``` Now that we have Elixir LS installed and compiled, let's get it set up in Neovim. ```lua -- A callback that will get called when a buffer connects to the language server. -- Here we create any key maps that we want to have on that buffer. local on_attach = function(_, bufnr) local function map(...) vim.api.nvim_buf_set_keymap(bufnr, ...) end local map_opts = {noremap = true, silent = true} map("n", "df", "lua vim.lsp.buf.formatting()", map_opts) map("n", "gd", "lua vim.lsp.diagnostic.show_line_diagnostics()", map_opts) map("n", "dt", "lua vim.lsp.buf.definition()", map_opts) map("n", "K", "lua vim.lsp.buf.hover()", map_opts) map("n", "gD", "lua vim.lsp.buf.implementation()", map_opts) map("n", "", "lua vim.lsp.buf.signature_help()", map_opts) map("n", "1gD", "lua vim.lsp.buf.type_definition()", map_opts) -- These have a different style than above because I was fiddling -- around and never converted them. Instead of converting them -- now, I'm leaving them as they are for this article because this is -- what I actually use, and hey, it works ¯\_(ツ)_/¯. vim.cmd [[imap

vsnip#available(1) ? '(vsnip-expand-or-jump)' : '']] vim.cmd [[smap

vsnip#available(1) ? '(vsnip-expand-or-jump)' : '']] vim.cmd [[imap vsnip#jumpable(1) ? '(vsnip-jump-next)' : '']] vim.cmd [[smap vsnip#jumpable(1) ? '(vsnip-jump-next)' : '']] vim.cmd [[imap

vsnip#jumpable(-1) ? '(vsnip-jump-prev)' : '']] vim.cmd [[smap

vsnip#jumpable(-1) ? '(vsnip-jump-prev)' : '']] vim.cmd [[inoremap

compe#complete()]] vim.cmd [[inoremap compe#confirm('')]] vim.cmd [[inoremap

compe#close('')]] vim.cmd [[inoremap

compe#scroll({ 'delta': +4 })]] vim.cmd [[inoremap

compe#scroll({ 'delta': -4 })]] -- tell nvim-cmp about our desired capabilities require("cmp_nvim_lsp").update_capabilities(capabilities) end -- Finally, let's initialize the Elixir language server -- Replace the following with the path to your installation local path_to_elixirls = vim.fn.expand("~/.cache/nvim/lspconfig/elixirls/elixir-ls/release/language_server.sh") lspconfig.elixirls.setup({ cmd = {path_to_elixirls}, capabilities = capabilities, on_attach = on_attach, settings = { elixirLS = { -- I choose to disable dialyzer for personal reasons, but -- I would suggest you also disable it unless you are well -- acquainted with dialzyer and know how to use it. dialyzerEnabled = false, -- I also choose to turn off the auto dep fetching feature. -- It often get's into a weird state that requires deleting -- the .elixir_ls directory and restarting your editor. fetchDeps = false } } }) ``` Elixir LS should be all set up now! Let's test it out by seeing if autocompletion, documentation on hover, and go to definition is working. ![Gif demonstration of autocomplete, documentation on hover, and go to definition](https://res.cloudinary.com/mhanberg/image/upload/v1621999434/elixir-ls-demo.gif) ## Integrating Credo I decided to completely remove [ALE](https://github.com/dense-analysis/ale), so I was wondering how I might get linters and formatters like credo and prettier hooked back in. Luckly, there are a few projects that implement a language server for the purpose of running these tools for you. I am currently using [efm-langserver](https://github.com/mattn/efm-langserver). I install efm with brew. ```shell $ brew install efm-langserver ``` Once that is installed, let's hook it up to Neovim. ```lua lspconfig.efm.setup({ capabilities = capabilities, on_attach = on_attach, filetypes = {"elixir"} }) ``` And last, we need to teach efm how to speak Credo. Create a new file at `~/.config/efm-langserver/config.yaml`. Please note that we need to run Credo with `MIX_ENV=test` or else it's going to mess with Phoenix code reloading. ```yaml version: 2 tools: mix_credo: &mix_credo lint-command: "MIX_ENV=test mix credo suggest --format=flycheck --read-from-stdin ${INPUT}" lint-stdin: true lint-formats: - '%f:%l:%c: %t: %m' - '%f:%l: %t: %m' lint-category-map: R: N D: I F: E W: W root-markers: - mix.lock - mix.exs languages: elixir: - <<: *mix_credo ``` Now you should be seeing Credo checks showing up inside Neovim. ## My Setup If you would like to check out my actual dotfiles, feel free to check them out on [GitHub](https://github.com/mhanberg/.dotfiles). I've extracted quite a few helper modules and functions that make organizing my plugins a little easier. Enjoy!

A Brief History of Time

Wed, 02 Jun 2021 04:40:32 GMT

Video companion - Teaching Elixir - Pattern Matching

Mon, 31 May 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover pattern matching. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. Today’s goof is to call the whole thing Learning Elixir at the start. Also we had to start over once because I screwed up the entire Livebook.

Announcing Temple v0.6!

Tue, 25 May 2021 10:00:00 -04

From Mitchell Hanberg's Blog: v0.6 of Temple has been released! 🎉 This release is the result of a few architecture changes that allows for faster rendering as well as many new features. _If you'd like to follow along with the code in this article, it's available [here](https://github.com/mhanberg/temple_example)_. ## Compile time output of EEx Temple now outputs EEx at compile time, allowing us to piggy back on the power of existing EEx Engines, such as the engines included by the [Phoenix Framework](https://phoenixframework.org). If you're using Temple with Phoenix, your templates should now be just as fast as the standard Phoenix templates, since the EEx output of Temple is piped right into the Phoenix template engine. Compiling to EEx also means that Temple is now compatible with [Phoenix LiveView](https://github.com/phoenixframework/phoenix_live_view)! This is made possible by the same process outlined above, without having to re-invent any wheels. ## Improved Component API The current component API is module driven and comes with support for "slots". Let's write a `Card` component to see how this all works. A Temple component begins with importing the `Temple.Component` module, which brings us the `render/1` and `defcomp/2` macros. ### defcomp `defcomp` allows us to create a basic component within any module. The only limitation is that you can't define any functions inside of it, as the body of the macro is the markup of the component. Here we are creating several more components using `defcomp`, but you can use this macro anywhere. Under the hood, it defines a Temple component module. ### render `render` is where your component markup will go. Since Temple components are basically the same as Phoenix views, this macro expands into a render function that takes assigns, which you can access like `@my_assign` just like you would do in a normal EEx template. ### slot Inside each component definition, you'll see the usage of `slot :default`. This is the proper way to render the inner content of the component that is defined at the call site. `slot` is more like a _keyword_, as it is not a macro or a function. ```elixir defmodule TempleExampleWeb.Components.Card do import Temple.Component defcomp Header do header class: "p-4 border-b border-gray-300 bg-gray-50 rounded-t-lg" do div class: "flex items-center space-x-4" do slot :default end end end defcomp Body do div class: "p-4 border-b border-gray-300" do slot :default end end defcomp Footer do footer class: "bg-gray-50 rounded-b-lg p-4" do ul class: "flex items-center" do slot :default end end end render do div class: "bg-white w-full flex flex-col rounded-lg shadow-lg" do slot :default end end end ``` Here we've defined a `Card` component as well as `Card.Header`, `Card.Body`, and `Card.Footer` components. Now we can easily compose these components together to create a few cards. ### c We render a component calling the `c` _keyword_ with a component module. I decided to keep this keyword as short as I could to make using components as ergonomic as possible. In the beginning, I wanted to be able to render them _without_ any keyword, but calling a module like a function is not valid Elixir syntax, so I couldn't do that. ```elixir div class: "grid grid-cols-3 gap-4 p-4 items-start" do for user <- @users do c Card do c Card.Header do div class: "w-10 rounded-full overflow-hidden flex-shrink-0" do div class: "aspect-w-1 aspect-h-1" do img class: "object-cover", src: user.avatar end end div do: user.name end c Card.Body do text_to_html(user.bio, attributes: [class: "first:mt-0 mt-2"]) end unless Enum.empty?(user.socials) do c Card.Footer do c LinkList, socials: user.socials do slot :link, %{text: text, url: url} do c LinkList.Item, url: url do text end end end end end end end end ``` ![Screenshot of 3 cards created using the above code snippet](https://res.cloudinary.com/mhanberg/image/upload/v1621913949/Screen_Shot_2021-05-24_at_11.41.34_PM.png) The `Card` related components all called `slot :default` to render their inner content, but as we can see inside our usage of `LinkList` within the `Card.Footer` component, we call `slot :link, %{text: text, url: url}`, why is that?? I'm glad you asked. The key feature of slots in my eyes is the ability for a component to pass data back into the scope of the caller. Before, we were _rendering_ a slot, whereas now we are _defining_ a slot. It's pretty easy to think of this in the context of a function that takes an anonymous function as an argument, like how you usually render a form in a Phoenix project. ```elixir form_for(@user, Routes.user_path(@conn, :edit, @user.id), fn form -> # markup and functions that use the form end) ``` If we were to make a form _component_, we could use a slot to do the same thing. You can see in these examples that we can pattern match on the assigns that are passed to the slot, allowing us to easily rename a variable if we want. Here's how we might make a form component that is compatible with how we're supposed to write forms in LiveView. ```elixir defmodule TempleExampleWeb.Components.Form do import Temple.Component render do form_for(@changeset, @path) slot :form, form: form_for(@changeset, @path) "" end end # usage alias TempleExampleWeb.Components.Form c Form, changeset: @user, path: Routes.user_path(@conn, :edit, @user.id) do slot :form, %{form: f} do # markup and functions that use the form end end ``` The nice part of slots is that we can have more than one and control exactly where they are rendered inside the component. Let's take another look at our `Card.Header` component to see what I mean. ```elixir defcomp Header do header class: "p-4 border-b border-gray-300 bg-gray-50 rounded-t-lg" do div class: "flex items-center justify-between" do div do slot :left end slot :default div do slot :right end end end end ``` Now we can slot (😅) some markup into specific parts of the component. ```elixir c Card.Header do slot :left do div class: "w-10 rounded-full overflow-hidden" do div class: "aspect-w-1 aspect-h-1" do img class: "object-cover", src: user.avatar end end end slot :right do SVG.verified_icon() end div do: user.name end ``` ## What's Next? While Temple has certainly come a long way, there are still many improvements to be made! The ones that I can immediately think of include: - [Fallback content for slots](https://github.com/mhanberg/temple/issues/129) - [Allow multiple instances of a single slot name](https://github.com/mhanberg/temple/issues/130) - [Use a component as a "typed" slot](https://github.com/mhanberg/temple/issues/128) - Improve stacktraces. Currently if something goes wrong, you might see errors/warnings being rendered on the wrong lines. - Writing guides. The hex documentation is alright, but doesn't really teach you how to use Temple. - Write a "component library" a la something like [React Bootstrap](https://react-bootstrap.github.io/) - New logo 👨‍🎨 --- ## Related Reading - [Temple, AST, and Protocols](/temple-ast-and-protocols) - [Introducing Temple: An elegant HTML library for Elixir and Phoenix](/introducing-temple-an-elegant-html-library-for-elixir-and-phoenix/) - [Release Notes](https://github.com/mhanberg/temple/releases/tag/v0.6.0)

Video - Building a web crawler

Fri, 21 May 2021 06:00:00 +0000

From Underjord.io: Had some great fun building on this webcrawler on the stream. Plan to continue with this in coming livestreams, so watch this to get up to speed on what we are doing. We grab an HTTP client, and HTML parser and then we go hog wild spawning Task processes and fetching web pages. The project repo I built up during the stream is on Github as lawik/caterpillar and the video is below.

Video companion - Teaching Elixir - Enums

Mon, 17 May 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover enum. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. There was an audio issue while recording that couldn’t be isolated and fixed where my friend was quite a bit lower in volume than I was.

Video - Native UI with Elixir and wxWidgets

Fri, 14 May 2021 06:00:00 +0000

From Underjord.io: This livestream turned out well. We got the Erlang wx module to work as intended in Elixir. We built a window, we made some controls, we made them interact. Good fun. This stream connects to some previous thoughts I’ve expressed about taking shortcuts in software or prioritizing developer experience over end-user experience, efficiency, consistency and so on. I wrote about that as the idea of artisanal software. wxWidgets is a bit more pragmatic than that lofty post.

Video - PETAL Stack Setup

Tue, 11 May 2021 06:00:00 +0000

From Underjord.io: Last weeks livestream was spent mostly on setting up the PETAL stack basics for a project. So if you want the video version of setting up PETAL with my guide this is for you. Then we also spent some time setting up Exqlite so we can use Sqlite instead of Postgres. That worked nicely, we tested it with phx.gen.auth. I will try to find some time to make a post on this later.

Video companion - Teaching Elixir - Collections

Mon, 10 May 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover collections. You can find the very simplistic Livebook version of the Elixir school content on my forked Elixir School repo for now. The video is also available on YouTube. Sorry, your browser doesn't support embedded videos. If you enjoy this or have questions you can reach me via email as lars@underjord.

Video companion - Teaching Elixir - Basics

Mon, 03 May 2021 06:00:00 +0000

From Underjord.io: Me and an experienced programmer friend sit down and try to teach him Elixir using the Elixir School curriculum and materials. We are doing it in Livebook. This time we cover the very basics. This is the first episode and we’ll definitely polish our process as we go. They will be much shorter and probably simpler than the live stream videos. The goal is to work through Elixir School and get my friend properly started with Elixir.

Video - Stream Overlay with LiveView

Fri, 30 Apr 2021 06:00:00 +0000

From Underjord.io: A livestream where I created some parts of an overlay for my stream. In this case it shows some indication of what we do during a coding stream by showing lines-of-code stats as we go. This is the view-at-your-leisure archival footage of that. This time in 1080. Also available on the YouTube. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.

Membrane Media Processing & LiveView

Mon, 26 Apr 2021 06:00:00 +0000

From Underjord.io: Membrane Framework allows processing media streams in a very high-level compelling way with Elixir. I’ve been wanting to work with it for a while and finally did a small thing with it around my most recent livestream. When we did the live stream we didn’t get it all the way to where I wanted. This resolves that. At the end of the post there is also a video showing you what the thing does.

Video - Membrane Framework, trying it out

Fri, 23 Apr 2021 06:00:00 +0000

From Underjord.io: Another live stream. I’ve been very curious to try Membrane and I finally got to screw around with it some. Thanks to Marcel Fahle for being a patient and helpful guest. The post about making a Twitch clone that was referenced is this one. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } Sorry, your browser doesn't support embedded videos.

Video - Livebook, trying it out

Mon, 19 Apr 2021 06:00:00 +0000

From Underjord.io: Last friday I did my second live stream. A lot of nice people stopped by and I spent the time showing and getting more familiar with the newly released [Livebook](https://dashbit.co/blog/announcing-livebook). Wasn't planning on providing a VOD (Video-On-Demand) of it but a bunch of people asked so I did. But this means it is only available in 720p. I'll be experimenting with this going forward. Video below. function switch_video(element) { var src = element.

Temple, AST, and Protocols

Mon, 12 Apr 2021 10:00:00 -04

From Mitchell Hanberg's Blog: As [Temple](https://github.com/mhanberg/temple) has aged, my ambition for this little library has grown. Temple started with the ability to produce HTML at runtime, but now includes: - EEx output target - LiveView support (it's just EEx after all!) - Basic component functionality (essentially just partials) If my goals for this project are going to evolve, so does the code base. So far I've been able to accomplish this with a rather naive and imperative compilation process. I figured that writing an actual abstract syntax tree (AST) as an intermediate format (IF) would be the next step, and along that journey I also found a nice use case for a [protocol](https://elixir-lang.org/getting-started/protocols.html). Before we look at the new AST, let's go over how things used to work. The previous method would recursively traverse Elixir AST, storing the collected tokens in a global buffer (backed by an [Agent](https://hexdocs.pm/elixir/Agent.html)). ```elixir buffer = Agent.start_link(fn -> [] end) Utils.traverse(ast, buffer) markup = buffer |> Agent.get(fn buf -> buf end) |> Enum.reverse() |> Enum.join("\n") ``` The `Utils.traverse/2` function would call a certain parser based on the Elixir AST with which it was working. The parser that would be invoked for lines that include anonymous functions looked something like this. ```elixir {_do_and_else, args} = args |> Utils.split_args() {args, func_arg, args2} = Utils.split_on_fn(args, {[], nil, []}) {func, _, [{arrow, _, [[{arg, _, _}], block]}]} = func_arg Agent.update(buffer, fn buf -> markup = "<%= " <> to_string(name) <> " " <> (Enum.map(args, &Macro.to_string(&1)) |> Enum.join(", ")) <> ", " <> to_string(func) <> " " <> to_string(arg) <> " " <> to_string(arrow) <> " %>" [markup | buf] end) Agent.update(fn buf -> ["\n" | buf] end) Utils.traverse(buffer, block) if Enum.any?(args2) do post_fn_args = args2 |> Enum.map(fn arg -> Macro.to_string(arg) end) |> Enum.join(", ") Agent.update(fn buf -> ["<% end, " <> post_fn_args <> " %>" | buf] end) Agent.update(fn buf -> ["\n" | buf] end) else Agent.update(fn buf -> ["<% end %>" | buf] end) Agent.update(fn buf -> ["\n" | buf] end) end ``` This code illustrates that I am compiling the Elixir AST into markup all in one pass and utilizing some global state to store the compiled markup. Named Slots, the feature that I want to build before cutting the v0.6.0 release, would be extremely complex or impossible to write with the architecture I described above. Let's discuss the AST and the benefits. ## Temple AST The AST follows a basic tree structure. Below I've demonstrated how some code you've probably written before would be represented by the AST. ```elixir form_for @conn, Routes.widget_path(@conn, :create), fn f-> label f, :name do span class: "text-bold" do "Name:" end text_input f, :name, placeholder: "Name..." end end # parses into %AnonymousFunctions{ elixir_ast: # the quoted expression from above, children: [ %DoExpressions{ elixir_ast: {:label, [], [{:f, [], Elixir}, :name]}, children: [ %NonvoidElementsAliases{ name: "span", attrs: [class: "text-bold"], children: [ %Text{text: "Name:"} ] }, %Default{ elixir_ast: {:text_input, [], [{:f, [], Elixir}, :name, [placeholder: "Name..."]]} } ] } ] } ``` The biggest benefit to the AST is its role as an _intermediate format_. Since we've explored the entire AST, we can now run it through another step before generating the final output. The goal is to target EEx, but now that we have the IF, we could write a generator that targets ANSI sequences for a CLI or maybe even [Scenic](https://github.com/boydm/scenic)! This brings us to our next topic, protocols! ## Protocols The EEX generator step utilizes a [protocol](https://elixir-lang.org/getting-started/protocols.html) to be able to compile Temple AST into an `iolist` that represents EEx. Each AST module implements this protocol and this allows any protocol implementation to generate any child nodes it contains without concerning itself with the shape of the children. The implementation for the `Text` node type is the easiest to understand. ```elixir defmodule Temple.Parser.Text do # ... defimpl Temple.Generator do def to_eex(%{text: text}) do [text, "\n"] end end end ``` The benefit of using a protocol becomes clear when we look at the `NonvoidElementsAliases` implementation. The highlighted line belows shows how the protocol makes recursively compiling the AST super easy. ```elixir defmodule Temple.Parser.NonvoidElementsAliases do # ... defimpl Temple.Generator do def to_eex(%{name: name, attrs: attrs, children: children}) do [ "<", name, Temple.Parser.Utils.compile_attrs(attrs), ">\n", for(child <- children, do: Temple.Generator.to_eex(child)), "\n" ] end end end ``` Since the implementation takes advantage of `iolist`s, we can easily compute the final markup without maintaining any state or dealing with cumbersome return values. Once `to_eex` returns, we just run that through `:erlang.iolist_to_binary/1` and we're good to go! ## What's Next With a proper AST in place, I can now move forward with the Named Slots API, which is the missing piece of the puzzle to make the Component API _really_ slick. Eventually, you should be able to write something like this. (The exact syntax is subject to change) ```elixir c Card, data: @person do slot :header, %{data: person} do "Full name: #{person.first_name} #{person.last_name}" end # some card body slot :footer, %{data: person} do "Find me on Twitter: " a href: "https:twitter.com/#{person.socials.twitter}" do "@" <> person.socials.twitter end end end c Card, data: @company do slot :header, %{data: company} do "Legal name: #{company.name}" end # some card body slot :footer, %{data: company} do "Contact support at:" a href: "tel:" <> company.phone_number do person.phone_number end end end ``` See you next time!

Lumen - Statically compiled Erlang for x86

Thu, 08 Apr 2021 06:00:00 +0000

From Underjord.io: The Lumen Project is an ambitious compiler development effort to create a complimentary set of compilers and tools that allow developers to get the power of the Erlang VM, The BEAM, in places it does not traditionally fit. Such as the browser. Currently the project is at an early released stage as covered in this talk. It does not yet implement all of Erlang OTP and as such won’t handle most Erlang/Elixir you could throw at it.

The Perils of Large Files

Mon, 05 Apr 2021 11:00:00 +0000

From Posts on Claudio Ortolina:

I recently wrote a blog post about working with large files in Elixir and OTP at PSPDFKit's blog.

The post originated from a talk I gave last year for ElixirConf.eu, but it contains more precise analysis.

A Telegram Bot in Elixir feat. LiveView

Wed, 24 Feb 2021 07:00:00 +0000

From Underjord.io: I asked my network on Twitter about noting ideas quickly and got a lot of good responses. One mentioned saving them in Telegram. I don’t think I want to do specifically that but I do want a minimum friction way of noting ideas for later review and refinement. And sending them to a Telegram chat would be quite nice. So I started on the path of something like a note-taking system using Telegram for ingesting quick notes.

Small update, full content RSS

Mon, 22 Feb 2021 06:00:00 +0000

From Underjord.io: This is a small update to let you know that the RSS feed contains full content now. It also lets me verify that the feed has updated correctly and works fine. If it comes out weird in your feed reader, please let me know. If you aren’t familiar with RSS. Consider it the open standard that drives podcasting and an exceptionally useful way of reading blogs, news, webcomics in a more intentional way via a dedicated, nice, newsreader application or web UI.

Post-mortem: 10 years in the vertical - Part 3

Fri, 12 Feb 2021 07:00:00 +0000

From Underjord.io: Content warning: Contains poor technical decisions, inexperience and stories of a developer just starting out and up to roughly present day. Be kind to who I was, he gets enough shit from me. This continues our dive from Part 2. Part 1 can be found here. The better system 2.0 The big embarrassment of the system we’d previously built was performance, it wasn’t scaling with a growing customer base and was slowing down.

Post-mortem: 10 years in the vertical - Part 2

Fri, 29 Jan 2021 07:00:00 +0000

From Underjord.io: This continues our dive from part 1. Content warning: Contains poor technical decisions, inexperience and stories of a developer just starting out and up to roughly present day. Be kind to who I was, he gets enough shit from me. The better system The team that had formed inside our little division of this larger organisation ended up breaking out to run an agency startup. Apps and web development would be our game.

Crafting Beautiful Emails in Elixir Using MJML

Wed, 20 Jan 2021 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about what exactly MJML is, why it is an awesome tool for creating slick looking emails, how to build MJML templates during the Elixir compilation phase, and how we go about sending these beautiful emails using Swoosh. In order to make this a bit more real world, we’ll also be leveraging Phx.Gen.Auth and will craft a great looking welcome email to ensure our new users feel extra welcome to our new SaaS platform ;).

Getting started with PETAL

Mon, 18 Jan 2021 13:00:00 +0000

From Underjord.io: I recently wrote about the PETAL stack on Changelog.com and as I haven’t really had a chance to really get my hands dirty with it I decided that my next lab project should use it. So I set it up as a public repo and added the missing components manually by following some guides. You can see the commits or follow along. So I used Phoenix 1.5.6 that I had already installed.

Post-mortem: 10 years in the vertical - Part 1

Fri, 15 Jan 2021 06:00:00 +0000

From Underjord.io: Before I did the independent thing I was a developer at a few different companies. I worked on multiple things but one of the main things I worked on was a series of products in the preschool education segment here in Sweden, that’s the titular vertical. The products have since been shut down. This series of posts will cover my trajectory as a professional web developer as well as the evolution of these systems.

Advent Of Code makes me a better programmer

Mon, 11 Jan 2021 20:43:51 GMT

From Bits of Code - Pieces of Writing: Advent Of Code is a yearly event offered by Eric Wastl: every day before Christmas, you can unlock a daily code challenge and crack it with the programming language of your choice. I n this post I will share with you my Advent Of code takeaways.

Podcasts that supported my independence

Mon, 11 Jan 2021 13:30:00 +0000

From Underjord.io: I want to shine a light on some podcasts that I really appreciated as I made my bid for independence and went out to contract, consult and strap boots. Because in some aspects running your own business can be lonely. It suits me well but I also immensely appreciate having some voices that share my concerns, contribute to my thinking and sometimes just keep me company. Underjord is my business and most of the work is me doing things.

Elixir businesses doing well

Wed, 09 Dec 2020 13:00:00 +0000

From Underjord.io: I generally don’t track startup news and financing rounds closely but it filters in because I enjoy tech. And these two Elixir-based companies made a blip on my radar recently with their successful rounds. So why not. Let’s be a little bit business. So I don’t particularly love the VC-backed model of building businesses. It sort of makes sense for some types of endeavors but generally I’m an organic growth and small teams kind of person.

Eloquent Control Flow + Efficient Time Complexity in Elixir

Mon, 07 Dec 2020 22:09:34 GMT

From The Great Code Adventure: In this post, I break down my Advent of Code Day 1 solution and dive into how you can use recursion, pattern matching and custom guard clauses to implement even complex logic and control flow in an easy-to-reason about way that also avoids common time complexity pitfalls.

Wisps, a touch of whimsy

Thu, 03 Dec 2020 07:00:00 +0000

From Underjord.io: This has been the most fun I’ve had with JavaScript in some time. A spiritual successor to the stupid solution which allowed both me and my visitors to see the number of concurrent readers. It is also a piece of whimsy I’ve wanted to do for a while to add more magic and life to the site. The animations default to off to preserve CPU but do turn on the magic switch in the top right if you can and want to see the visuals.

The Race for Space

Sat, 28 Nov 2020 17:55:37 +0000

From Posts on Claudio Ortolina:

Public Service Broadcasting (PBS for short) are a trio based in London, whose music usually involves historical audio documents with a mix of jazz, rock and electronic.

Each one of their album revolves around a specific theme, usually inspired by modern/contemporary history, and includes a vast amount of archival audio footage, recording, and samples, with very little vocals on top.

In 2015 they released The Race for Space, a concept album that explores the first 15 years of the Space Race missions, from Sputnik 1's flight in 1957 to the last Apollo mission in 1972.

The general tone celebrates achievements of both US and Soviet Union, emphasising each step as a human endeavour that transcends borders and politics.

Between music, vocals and engineering, the album involved another 35 people, which is something you can only perceive after listening to it a few times: some of the instruments are particularly subtle and deserve special attention.

Each song has a different personality and it's difficult to attribute a general genre to the entire album, but I can feel a general underlying cohesion which makes it that I rarely listen to one song and prefer to just play the entire record.

1. The Race for Space

The album opens with rearranged fragments of US President John F. Kennedy's speech given at Rice University, Houston, Texas, on September 12, 1962. The speech sets the tone of the entire album, celebrating mankind's efforts to reach beyond the stars:

Many years ago, Great British explorer George Mallory
Who was to die on Mount Everest
Was asked 'why did he want to climb it?'
He said 'because it is there'
Well space is there and we're going to climb it
And the moon and the planets are there
And new hopes for knowledge and peace are there
And therefore as we set sail we ask God's blessing
On the most hazardous, and dangerous, and greatest adventure
On which man has ever embarked – John F. Kennedy

It's difficult to listen to this speech without anticipation, especially knowing what would happen 7 years later.

2. Sputnik

The second track, Sputnik, takes us to the Soviet Union in 1957, to tell the story of the first object ever sent into space, the low Earth orbit satellite Sputnik 1.

In Sputnik, the original sounds of the unmanned spacecraft gradually become part of the main beat and gradually build excitement for the beginning of "man's cosmic existence".

The man made celestial body, for the first time in history
Overcame terrestrial gravity and flew into space
All men of all nations recognise this as a great achievement
In an age where the race to conquer space has become an all-absorbing factor

The era of man's cosmic existence

Once again, the accent is on how people can be united by such an important event:

All over the world, people are tuning in to the 'bleep bleep bleep' of the satellite

A dream cherished by men for many centuries comes true on October the 4th, 1957

3. Gagarin

If Sputnik makes you tap your feet, then Gagarin will make you dance: to tell the story of the first ever cosmonaut, Yuri Gagarin, PBS wrote an explosive song, a mix of funk, brass, marching band, you-name-it tune that captures the euphoria of such an important moment.

The jump into the unknown is not something to be scared of:

The World's first cosmonaut
The first to open the door into the unknown
The first to step over the threshold of our homeland

Gagarin himself appreciated his new vantage point:

Astronaut to Earth: I can see forests, rivers, [?] all around
Everything's so beautiful, it's wonderful, it wonderful…

4. Fire in the Cockpit

After Gagarin, Fire in the Cockpit is a cold shower and a stark reminder of the risks and cost of exploration, telling the tragedy of Apollo 1, where three astronauts lost their lives due to a cabin fire during a test.

The entire song revolves around the sound of static and deep keyboard tones, with a cello entering midway as we listen to the words of NASA's description of the events. It's a sad song, but exhibits the composure and respect owed to people who lost their lives while trying to advance the frontiers of human knowledge.

5. E.V.A.

In E.V.A.¹ we hear the story of Alexei Leonov, Alexei Leonov completed the first spacewalk in 1965, spending 10 minutes outside in open space.

It's interesting how the music almost stops when the astronaut leaves the spacecraft, mimicking the silence of the vacuum of space. The few piano notes we can hear really complement the marvel of Leonov's words:

I'm on the edge of the opening
Of the airlock chamber
I feel excellent
I see clouds and the sea
I am beginning to move away

6. The Other Side

The Other Side takes us one step closer to the moon landing, focusing on the Apollo 8 mission, where for the first time a manned spacecraft completed an orbit of the moon, but from the unusual point of view of ground control.

We hear voices and recordings from the control room, where ground control monitors the spacecraft as it's about to reach the blind side of the moon. The excitement and anxiety are palpable: to complete a lunar orbit, Apollo will temporarily lose signal with earth.

Once again, the music tells the story without words, getting quiet during loss of signal and exploding into a liberating instrumental when Apollo finally replies back to Houston. The event is incredibly significant:

The unmanned lunar spacecraft traversed the moon perhaps over 10, 000 times
But this is the first that a man aboard reported to his compatriots here on Earth

7. Valentina

Valentina is a celebration of Valentina Tereshkova, the first woman to ever go to space n 1963 (and to this date, the only one having ever been in a solo mission).

The song, which features choruses from The Smoke Fairies, is a graceful instrumental without any other vocals. J. Willgoose, Esq. writes on the matter:

One of the biggest problems with the material we use, from the period we address, is that it almost totally devoid of any female voice.
It is often said that history is written by the winners, but it would be equally if not more apt to say that it has overwhelmingly been written by men. Of the footage I obtained of the first woman in space, all of it featured her voice being translated by male voices.
Rather than yet more men - us, in this case - attempting to speak on her behalf, it seemed more appropriate to ask a guest singer to provide a female voice, so we tried a different approach with 'Valentina' and I'm very glad we did.

8. Go!

The story of the Apollo 11 and the first crew to land on the moon in 1969 represents one of the most important moments of human history. Once again, PBS decides to focus on the point of view of the people on the ground, to celebrate the often unseen work of preparation, monitoring, incredible engineering that made the whole thing possible.

Go! is giant checklist, where we hear the flight director Gene Kranz go through all the checks needed to make sure that the descent on the moon will be successful. It's so interesting that the landing itself is just a couple of verses in the middle:

Houston, uh
Tranquility base here, The Eagle has landed

The repetition in the dialogues provides the rhythm of the song, which matches the excitement of the mission with upbeat percussions, synth and keyboard.

Go! is a reminder that we can achieve the impossible if we work together.

9. Tomorrow

The Apollo 17 mission, the last in the Apollo program, represents the end of an era and the last time we landed on the moon.

Tomorrow reflects on its significance: as a species, we managed to leave our own planet, albeit temporarily, and look beyond to a completely unexplored universe.

While it's not possible to separate the space race from the politics that fueled it in the first place, it's also a testament to the effort of thousands of people over decades, to literally take us where no one has ever been before.

As an outro, Tomorrow tempers the excitement of the previous songs and focuses more on choruses and keyboard, painting a picture of anticipation of what's gonna come next.

the name is a shorthand for extravehicular activity, which indicates a spacesuit designed for usage outside of a vehicle.

Asking a tech recruiter

Wed, 25 Nov 2020 07:00:00 +0000

From Underjord.io: Since I left my comfy job as the tech lead for a SaaS product and went into running my own business I took a closer look at my relationship with recruiters. While working I mostly found the attention of recruiters slightly reassuring but often annoying. I think that annoyance is fairly common, usually built up from countless LinkedIn drive-by attempts from unreading keyword-hunting recruiters. I thought that now, out on my own, maybe this legion of recruiters can be my sales department.

On Elixir Metaprogramming

Mon, 23 Nov 2020 17:00:00 GMT

From Bits of Code - Pieces of Writing: Metaprogramming is a scary word: it sounds like voodoo for programmers, and in some manners it is. It is used by most popular Elixir libraries and as I leveled up as an Elixir programmer, I needed to understand how it worked under the hood.

Building a Custom Page for Phoenix Live Dashboard

Sat, 21 Nov 2020 09:29:01 +0000

From Posts on Claudio Ortolina:

One of the most interesting features provided by Phoenix Live Dashboard is the ability to define your own pages, so that you can quickly and reliably extend a Live Dashboard instance with sections that are tailored to your application domain.

While working on Tune, I found a use case suitable for a custom live dashboard page: a debugging view where I can check open sessions and inspect the underlying processes.

On the use case

I would encourage you to read Tune's README to understand the use case in more detail, but I'll quote the relevant architectural section:

Tune assumes multiple browser sessions for the same user, which is why it defines a Tune.Spotify.Session behaviour with Tune.Spotify.Session.HTTP as its main runtime implementation.

Each worker is responsible to proxy interaction with the Spotify API, periodically poll for data changes, and broadcast corresponding events.

When a user opens a browser session, TuneWeb.ExplorerLive either starts or simply reuses a worker named with the same session ID.

Each worker monitors its subscribers, so that it can shutdown when a user closes their last browser window.

This architecture ensures that:

The amount of automatic API calls against the Spotify API for a given user is constant and independent from the number of user sessions for the same user.

Credential renewal happens in the background

The explorer implementation remains entirely focused on UI interaction

In other words:

For each Spotify account connected, there can only be one session (a Tune.Spotify.Session.HTTP process named with the session ID).
For each session, there can be many open clients (i.e. browser windows or TuneWeb.ExplorerLive process).

Requirements

Our dashboard page will include:

A table with session IDs, PIDs and count of open clients
Ability to sort by session ID or clients count
Search by session ID
Support multiple nodes

Gathering the necessary data

To populate the dashboard table, we first need to find a way to get a list of all active sessions, along with their clients count.

The simplest way is to leverage the fact that each Tune.Spotify.Session.HTTP process is started with a name managed via a Registry, with the session ID as a key. Registration is in place to guarantee that there can only be one session process with the same ID on each node.

We can use Registry.select/2 to query the registry and receive back all session IDs and PIDs:

Registry.select(
 Tune.Spotify.SessionRegistry,
 [{{:"$1", :"$2", :_}, [], [{{:"$1", :"$2"}}]}]
)

Which returns:

[{"claudio.ortolina", #PID<0.565.0>}]

In the example above, we use a match specification to capture the registry key (the session ID) and the registered PID.

It's important to understand straight away the constraints associated with this approach:

A Registry is normally split into a variable number of partitions, so this query has to visit all partitions to return its results. While this is not a problem at this stage (the application has very little load), it can become a bottleneck once the number of registered processes grows.
As data is partitioned, it's not possible to apply sort order or limit the results without concatenating them all first, which means that both operations will need to be done by the caller.
Results only apply to the current node, which works well with Phoenix Live Dashboard's general structure, which always operates on one node at a time.

Given the registry query above, we can implement a function that provides the data necessary to populate an unfiltered, unsorted version of the table:

defmodule Tune.Spotify.Supervisor do
 # omitted
 def sessions do
 Tune.Spotify.SessionRegistry
 |> Registry.select([{{:"$1", :"$2", :_}, [], [{{:"$1", :"$2"}}]}])
 |> Enum.map(fn {id, pid} ->
 subscribers_count = Tune.Spotify.Session.HTTP.subscribers_count(id)
 %{id: id, pid: pid, clients_count: subscribers_count}
 end)
 end
end

The resulting data structure is a map with the necessary data:

[%{clients_count: 1, id: "claudio.ortolina", pid: #PID<0.565.0>}]

Dashboard page structure

To build a dashboard page, we need to:

Create a module that implements the use Phoenix.LiveDashboard.PageBuilder behaviour.
Mount that module into the Live Dashboard configuration defined into our application router.

What follows is a minimal implementation that shows the data we need, with the following limitations:

no searching, sorting or limiting capabilities
works only on a single node

defmodule TuneWeb.LiveDashboard.SpotifySessionsPage do
 @moduledoc false
 use Phoenix.LiveDashboard.PageBuilder

 @impl true
 def menu_link(_, _) do
 {:ok, "Spotify Sessions"}
 end

 @impl true
 def render_page(_assigns) do
 table(
 columns: columns(),
 id: :spotify_sessions,
 row_attrs: &row_attrs/1,
 row_fetcher: &fetch_sessions/2,
 rows_name: "sessions",
 title: "Spotify Sessions"
 )
 end

 defp fetch_sessions(_params, _node) do
 # returns [%{clients_count: 1, id: "claudio.ortolina", pid: #PID<0.565.0>}]
 sessions = Tune.Spotify.Supervisor.sessions()

 {sessions, length(sessions)}
 end

 defp columns do
 [
 %{field: :id, header: "Session ID", sortable: :asc},
 %{
 field: :pid,
 header: "Worker PID",
 format: &(&1 |> encode_pid() |> String.replace_prefix("PID", ""))
 },
 %{field: :clients_count, header: "Clients count", sortable: :asc}
 ]
 end

 defp row_attrs(session) do
 [
 {"phx-click", "show_info"},
 {"phx-value-info", encode_pid(session[:pid])},
 {"phx-page-loading", true}
 ]
 end
end

The main ingredients of this implementation are:

The use Phoenix.LiveDashboard.PageBuilder directive, which adopts the behaviour with the same name and imports some convenience functions useful for building pages (e.g. encode_pid/1).
The menu_link/2 callback, which is used to define the name of the page and its label in the top navigation bar.
The render_page/2 callback, which has to return a valid component - in this case via the table/1 function.

The table definition has a few moving parts:

An id (unique among other Live Dashboard pages).
A title, shown in the page.
A rows_name, interpolated in the short text blurb that details the total amount of results.
A columns attribute, which is a list of maps detailing the properties of each column. For each column, the id property has to map to a key in the data we will use to populate the table. The sortable property defines which column can be used for sorting (by clicking on the header chevron). Note that unless you specify a default_sort_by attribute for the entire table, you have to have at least one column with the sortable property defined, otherwise you will get a compile error. The format function takes the raw value for a cell in the column and transforms it to a string. It's useful to provide a string representation of the value that is suitable for an HTML table. In the code above, we copy the format function defined in the Processes Live Dashboard page.
A row_attrs function, which takes the data for each row and has to return a list of tuples representing the Phoenix LiveView attributes to apply to the table row itself. Defining attribute is necessary to enable functionality activated by clicking on the row itself. The implementation in this example lets you inspect the session PID in a modal overlay. Similar to the format function, we leverage encode_pid/1 to format the PID as string compatible with the show_info LiveView event.
A row_fetcher function, which takes the current params (search query, limit, sort key, sort direction) and the current node, and returns the data used to populate the table. The return value has to conform to a tuple shape where the first value is a list of sessions (in the shape of maps with the same keys used for column ids) and the second value is the total number of results (irrespectively of the limit). As we implemented Tune.Spotify.Supervisor.sessions/0 taking care of using the same key names, its return value perfectly fits the expectations of the row_fetcher function.

Mounting the dashboard page

To have the page up and running, we need to modify the live_dashboard/2 function inside the application router:

live_dashboard "/dashboard",
 metrics: TuneWeb.Telemetry,
 metrics_history: {TuneWeb.Telemetry.Storage, :metrics_history, []},
 additional_pages: [
 spotify_sessions: TuneWeb.LiveDashboard.SpotifySessionsPage
 ]

Filters and limits

We can now focus on implementing search, sorting and limits. Conceptually, we need to:

If specified, apply the search filter.
Always apply sort order.
Count the sorted elements, to return the correct total.
Always apply the limit clause to the sorted elements.

All of these operations have to be handled by the implementation of the row_fetcher function.

The params map has the following keys:

:search: the string representing the contents of the search input (or nil when empty).
:sort_by: the id of the column to sort by.
:sort_dir: the sort direction, expressed with the atoms :asc and :desc.
:limit: the integer value representing the amount of max items requested by the user.

The params map is very well thought out, as it has a fixed structure, applied defaults where available and values that play well with functions from the Enum module.

We can extend the fetch_sessions/2 function as follows:

defmodule TuneWeb.LiveDashboard.SpotifySessionsPage do
 # omitted

 defp fetch_sessions(params, _node) do
 sessions =
 Tune.Spotify.Supervisor.sessions()
 |> filter(params)

 {Enum.take(sessions, params[:limit]), length(sessions)}
 end

 defp filter(sessions, params) do
 sessions
 |> Enum.filter(fn session -> session_match?(session, params[:search]) end)
 |> Enum.sort_by(fn session -> session[params[:sort_by]] end, params[:sort_dir])
 end

 defp session_match?(_session, nil), do: true
 defp session_match?(session, search_string), do: String.contains?(session[:id], search_string)
end

As outlined above, we start by filtering by search, using a very simple logic that just checks if the session ID contains the searched string.

After search, we apply the sorting logic: the values of the :sort_by and :sort_dir perfectly fit using Enum.sort_by/3 (a really appreciated API design choice), making the implementation short and sweet.

When defining the returning tuple, we take care of applying the limit and returning the correct total count.

With these changes in place, the generated table behaves as expected:

Supporting multiple nodes

The last piece of the puzzle is making sure that we take into account the currently selected node.

Fortunately, we just need to make a very small change to fetch_sessions/2:

defp fetch_sessions(params, node) do
 sessions =
 node
 |> :rpc.call(Tune.Spotify.Supervisor, :sessions, [])
 |> filter(params)

 {Enum.take(sessions, params[:limit]), length(sessions)}
end

The OTP rpc module conveniently provides a call/4 function that takes a node name, module, function, and arguments, returning the exact same value of the remotely executed function.

Conclusions

To see the final version of TuneWeb.LiveDashboard.SpotifySessionsPage, you can open the file in the repo.

The Mac is losing me

Wed, 18 Nov 2020 07:00:00 +0000

From Underjord.io: I’ve been mostly happy using a Mac since I got myself my first computer earned with programmer money. I believe it was a mid 2009 15" MacBook Pro. That was a computer I used at least until 2016 which I consider very decent usable life. At that point I had replaced the hard-drive with an SSD, upgraded the RAM and switched a battery that was worn out. I stopped using it when it just straight died some time in 2016.

Tips for Finch, Telemetry, and Phoenix Live Dashboard

Tue, 17 Nov 2020 17:27:05 +0000

From Posts on Claudio Ortolina:

While working on Tune, I needed to collect performance metrics related to the interaction with the Spotify API.

The Finch HTTP client exposes Telemetry metrics, which made it very easy to display them via Phoenix Live Dashboard.

Starting from the stock TuneWeb.Telemetry file generated by Phoenix (see the official guides for an explanation), I just added two new summary metrics to the metrics/0 function:

 summary("vm.total_run_queue_lengths.io"),

 # HTTP
 summary("finch.request.stop.duration", unit: {:native, :millisecond}, tags: [:path]),
 summary("finch.response.stop.duration", unit: {:native, :millisecond}, tags: [:path])
]

With this change in place (commit), I had all metrics being visualized in the dashboard, grouped by the Spotify API path. I wanted to make some improvements:

The :path tag includes query string parameters, so calls like search?q=marillion and search?q=fish would be aggregated in different groups. Instead, I would want them to be part of the same group, ignoring query string parameters.
Since I setup Sentry to use Finch as a client, I wanted to exclude calls made to Sentry and only have charts reporting metrics about the interaction with Spotify

Aggregating by normalized path

To aggregate metrics by normalized path, we can apply a transformation function to the metric tag values, generate a normalized path tag and use that to aggregate metrics. As shown in the telemetry_metrics docs, the option we need is tag_values:

def metrics do
 [
 # omitted
 summary("finch.request.stop.duration",
 unit: {:native, :millisecond},
 tags: [:normalized_path],
 tag_values: &add_normalized_path/1
 )
 ]
end

defp add_normalized_path(metadata) do
 Map.put(metadata, :normalized_path, URI.parse(metadata.path).path)
end

We can use the built-in URI module to parse normalized path out of the Finch metric metadata and add it to the metadata itself. With that in place, we can update the tags option to reference :normalized_path. With this change, metrics are aggregated on the endpoint only, without any query string. For reference, here's the relevant commit.

Filtering only Spotify calls

To filter for Spotify calls only, we can use the keep option, which specifies a predicate function that can be used to define which metrics should be kept and which ones should be discarded. Discarded metrics will not appear in the dashboard chart.

def metrics do
 [
 # omitted
 summary("finch.response.stop.duration",
 unit: {:native, :millisecond},
 tags: [:normalized_path],
 tag_values: &add_normalized_path/1,
 keep: &keep_spotify/1,
 reporter_options: [
 nav: "HTTP - Spotify"
 ]
 )
 ]
end

defp keep_spotify(meta) do
 meta.host =~ "spotify"
end

As the meta information already includes a host, we can compare it with the spotify string. The =~ operator makes the comparison a bit more resilient, so that we don't have to worry about the exact hostname, rather a hostname related to Spotify. This choice might need to be revised if we ever end up interacting via HTTP with another service with "spotify" in their host name (unlikely, but possible).

For some additional clarity, we can also use the nav reporter option (see Phoenix LiveDashboard documentation for more details) to make sure that the navigation header displays a name that details the additional filter applied to the HTTP metrics. For reference, see the relevant commit.

Conclusion

Both improvements required very small updates. Here's the final result, showing the custom Nav title ("HTTP - Spotify") to hint at the filter used to only show Spotify calls, and aggregation by normalized path (without query string).

All in all, I was pleased to see that it was straightforward to customise the charts I needed. One thing I haven't worked on yet is aggregating metrics by logical path, i.e. by route (GET /artist/:id) instead of individual paths (GET /artist/123), but I have some ideas and will come back on it in a future post.

Using Finch With Sentry

Tue, 10 Nov 2020 08:41:30 +0000

From Posts on Claudio Ortolina:

A few weeks ago I added enabled support for Sentry inside Tune, my Spotify browser/client. Even if I'm pretty much the only user (I built it for myself after all), having exception tracking has already proved to be useful - band and song names can really create all sorts of issues.

The official Sentry package works as advertised and by default it communicates using Hackney as a http client. As I've been using Finch in the project, I was pleased to see that Sentry exposed a client configuration option that allowed using your own module, as long as it implemented the Sentry.HTTPClient behaviour.

The advantage in swapping the http client library (on top of uniforming the building blocks of the application) is that Finch has support for Telemetry metrics.

Update #1: Thanks to Wojtek Mach for a more streamlined implementation.

The module I wrote is quite short:

defmodule Sentry.FinchClient do
 @moduledoc """
 Defines a small shim to use `Finch` as a `Sentry.HTTPClient`.
 """

 @behaviour Sentry.HTTPClient

 @impl true
 def child_spec do
 Finch.child_spec(name: Sentry.Finch)
 end

 @impl true
 def post(url, headers, body) do
 request = Finch.build(:post, url, headers, body)

 case Finch.request(request, Sentry.Finch) do
 {:ok, response} ->
 {:ok, response.status, response.headers, response.body}

 error ->
 error
 end
 end
end

The trickiest bit was to get the child_spec/0 callback right while keeping dialyzer happy. The first implementation I wrote was simply {Finch, name: Sentry.Finch}, but that would fail to satisfy the typespec defined for child_spec/0. I then switched to a more verbose version:

 def child_spec do
 opts = [name: Sentry.Finch]

 Supervisor.child_spec(
 %{
 id: __MODULE__,
 start: {Finch, :start_link, [opts]},
 type: :supervisor
 },
 []
 )
 end

This version satisfied dialyzer, but turns out there's a simpler way. After publishing this blog post, Wojtek Mach reached out and submitted a PR to streamline the specification to the version shown in the full example above.

I also updated my production configuration:

config :sentry,
 dsn: {:system, "SENTRY_DSN"},
 environment_name: :prod,
 enable_source_code_context: true,
 root_source_code_path: File.cwd!(),
 client: Sentry.FinchClient,
 included_environments: [:prod]

You can of course expand on this implementation if you need to pass more options to the Finch child specification - I found that for my use case, defaults are fine, so for now I don't need to add any configuration hooks.

To see the change in context, this is the original PR, with the follow-up by Wojtek Mach.

Fish

Fri, 06 Nov 2020 12:28:16 +0000

From Posts on Claudio Ortolina:

Prelude

I have very early memories of rock music in my life. Since I was a toddler, my parents (and particularly my dad) got me used to listen to 80s rock music. Bands like Queen, Guns N' Roses, AC/DC, Van Halen, and Bon Jovi are ingrained in my memories as sounds of my childhood.

It's not surprising that my taste in music has developed from there, branching out over the years in metal and progressive rock. Music is a constant companion of my daily life and contributed to the formation of my identity.

My taste changed and adapted: around ten years ago I was dismissing Operation: Mindcrime by Queensrÿche as a mediocre album, but two years ago I picked it up again and it was a revelation. Something similar happened while listening to Rage Against the Machine, Tool or A Perfect Circle, didn't like them years ago, absolutely love them now.

This change got me thinking - why do these bands resonate with me now?

I think the answer lies primarily in the integrity of the message connected to these bands: their perspective, political stance, perspective on life really struck a cord with me in my 30s. They take an explicit position around issues I care about.

Enter Marillion and Fish

Until a year ago, I had a very cursory knowledge of Marillion's body of work. I kney they existed, that they have a substantial discography and that they represent an important page in the history of 80s and 90s prog.

One morning, Spotify's suggestions algorithm decided to play Incommunicado and Sugar Mice in the space of an hour. I found myself stopping what I was doing in both instances - there was something about those songs that really dragged my attention. I loved the music - but the lyrics stopped me in my tracks.

Incommunicado is about ambition, the drive to make it big without taking responsibilities. In the context of the entire album, it's both a metaphor for the difficult life of Torch, the main character whose life is falling to pieces, but also a direct description of the music business.

Sugar Mice is a song about the devastating effects of unemployment and economic recession. The title refers to a popular english sweet made of sugar. The main refrain "We're just sugar mice in the rain" gives a very vivid representation of how fragile life can be.

The words, references, and metaphors included in the lyrics stood out as something completely out of the ordinary - it sounded like poetry.

The more I explored other Marillion's songs, the more I realized that what really resonated with me was Fish, their initial singer and lyricist. Following his body of work after he left Marillion, I kept finding incredible songs.

Love and relationships

Do you remember?
Barefoot on the lawn with shooting stars
Do you remember?
The loving on the floor in Belsize Park
Do you remember?
Dancing in stilettoes in the snow
Do you remember?
You never understood I had to go
By the way, didn't I break your heart?
Please excuse me, I never meant to break your heart
So sorry, I never meant to break your heart
But you broke mine — Kayleigh, 1985

By far the most succesful Marillion song, Kayleigh is often cited as Fish's apology to different women for the failure of their romantic relationships, a collage of vivid images and melancholic moments.

To me, this song sows the seeds of a theme that goes through a few songs written by Fish: work/life balance. Relationships fail when you divert your attention away from them, when you don't put in everyday work to keep them going.

In Zoë 25 it's the aftermath of another relationship that didn't go well:

When you're looking for somebody, you might not even see them,
When they're standing there in front of you, right before your eyes,
If you're looking for somebody you're gonna need some help,
You know you'll never find her when you're looking for yourself. — Zoë 25, 2007

In Garden of Remembrance, it's Alzheimer's disease, something completely outside our control:

He's lost between the here and now
Somewhere that he can't be found
She's still here
Her love a ghost of memory
She'll wait for an eternity
He's still here — Garden of Remembrance, 2020

In cliche, the song lyrics use estabilished cliches to acknowledge that no matter how much hard you try, sometimes the simplest thing you can say is what matters.

That's why I'm trying to say with my deepest sincerity
That's why I'm finding it comes down to the basic simplicities
The best way is with an old cliche
It's simply the best way is with an old cliche
Always the best way is with an old cliche
I'll leave it to the best way, it's an old cliche
I love you. — Cliche, 1990

In Punch and Judy¹ it's the progressive deterioration of a relationship, escalating in murdering fantasies:

Whatever happened to morning smiles,
Whatever happened to wicked wiles, permissive styles,
Whatever happened to twinkling eyes,
Whatever happened to hard fast drives,
Complements on unnatural size

Punch, Punch, Punch And Judy, Punch, Punch, Punch And Judy
Punch, Punch, Punch And Judy.

Propping up a bar, family car,
Sweating out a mortgage as a balding clerk,
Punch And Judy, [Judy]
World war three, suburbanshee,
Just slip her these pills and I'll be free.

No more Judy, Judy. Judy no more! Goodbye Judy! — Punch and Judy, 1984

Living on your own terms

Another recurring topic is the idea of living on your own terms. From Tongues, where Fish lets out the frustration of dealing with lawyers during a very long lawsuit with music publisher EMI:

Your entrenched opinions,
On the border of arrogance,
Dug in against the compromise.
A position indefensible, your actions illogical
You're speaking in tongues

You swear contradictions
Your tedious monologues, wielding authority,
Demanding subservience, demanding
I make your sense.
Demanding speaking in tongues. — Tongues, 1991

The inability to speak the same language becomes a massive blocker. The aforementioned lawsuit with EMI ended up being a fundamental event in Fish's life, pushing him to pursue the ownership of all rights of his solo albums (except the first one, Vigil in a Wilderness of Mirrors).

In Circle Line², it's the awareness of the 9-to-5 grind that is imposed on the majority of us:

9 to 5's the only time I try to kid myself that I'm still alive,
That I'm living out the dream to earn my freedom from this rat race
Where all I do's survive, I live the lie, I serve my time.

The circle line.

Just another day, just another day, just another day,
Just another day, just another day, just another day on the circle line.

The circle line, on the circle line. — Circle Line, 2007

Lost Plot, on losing track of what matters:

I was blinded by light but the vision had died, I'd forgotten
In time just what I was fighting for
I'd forgotten who's side I was on, the difference between
Right and wrong
I was out of my depth, going out of my mind, going down in
A field where no prisoners are taken, no quarter is given
The writing was small, it burned on the wall, I'd sold out
My soul for what it was worth
I'd lost the plot, my number was up, the game was over
Snakes and ladders, a world of snakes and ladders, snakes
And ladders — Lost Plot, 2004

View from the Hill, where we the hill is an endless collection of things that don't matter and just keep us imprisoned.

Artwork for the album of Vigil in the Wilderness of Mirrors, by Mark Wilkinson

You sit and think that everything is coming up roses
But you can't see the weeds that entangle your feet
You can't see the wood for the trees 'cause the forest is burning
And you say it's the smoke in your eyes that's making you cry

They sold you the view from a hill
They told you that the view from the hill would be
Further than you have ever seen before
They sold you a view from a hill
They sold you a view from a hill — View from the Hill, 1990

The system has failed (us)

Fish has never shied away from commenting on politics: from Market Square Heroes (Marillion's first single) to Weltschmerz, the ending track of his latest (and last) album.

Market Square Heroes³ is once again an anthem of an angry generation that suffers the consequences of austerity and recession:

I give peace signs when I wage war in the disco
I'm the warrior in the ultra violet haze
Armed with antisocial insecurity
I plan the path of destiny from this maze

Cause I'm a Market Square hero gathering the storms to troop
Cause I'm a Market Square hero speeding the beat of the street pulse
Are you following me, are you following me?
Well suffer my fallen angels and follow me
I'm the Market Square hero, I'm the Market Square hero
We are Market Square Heroes, to be Market Square Heroes — Market Square Heroes, 1982

Weltschmerz is a summary of all fights worth fighting - from climate change, to poverty, to the general failure of a political system that emphasized polarisation and division:

I am a grey bearded warrior, a poet of no mean acclaim
My words are my weapons that I proffer with disdain
My melancholy aspect is something you can’t disregard
My motives you cannot question nor my strong sense of right and wrong\\

I’ve formed the opinion that things can’t stay as they are
My anger and my fury trapped like a wasp in a jar
It’s never too late to make a brave new start
When the revolution is called I will play my part — Weltschmerz, 2020

Perfume River

Perfume River⁴ deserves a mention on its own: in this song, Fish looks at the consequences of the Vietnam War, whose images are burned in his childhood memory.

Artwork for the album Feast of Consequences by Mark Wilkinson

Fire breathing dragons swarm in sweltering skies, spewing flame on innocents below
Charred and brittle corpses, blackened evidence, I am enraged, I am afraid, I am forlorn
The ashes from wise pages fly from libraries, tumble in the clouds of smoke and flies
To lie as dust in corners of dark palaces, the fetid smell of revolution haunts the air.

Take me away to the Perfume River; carry me down to the perfume river
Set me adrift on a well-stocked open boat
Show me the way to the Perfume River, send me away down the perfume river
Pour that sweet, sweet liquor down my throat; pour it down my throat — Perfume River, 2013

Once again, the images evoked are incredibly strong, full of colour - red flames and rage, smoke, dust and death.

Visuals

A powerful ingredient in Fish's artistic work has always been his collaboration with Mark Wilkinson, who illustrated all Marillion's albums (until Fish left the band) and all of Fish's work. His surrealistic style is unmistakable and perfectly complements the "visual" nature of a lot of Fish's songs.

The title refers to Punch and Judy, the main characters of a puppet show popular in British culture. See the Wikipedia page for more information.

The Circle Line is one of London's Underground lines.

The title is both a reference to a market square in Ailesbury, an english town, and Nietzsche's Parable of the Madman.

⁴

The title refers to a river running through the city of Huế in Vietnam, one of the cities deeply affected by the Vietnam War.

How to Deploy a Phoenix App to Gigalixir in 20 Minutes

Fri, 06 Nov 2020 09:00:00 EST

From Mitchell Hanberg's Blog:

This is a quick screencast to demonstrate how easy it is to deploy an Elixir application to Gigalixir, a hosting platform built specifically for Elixir.

I included a condensed text version of the video for those who prefer it, but you can find the full guide here.

Create the Phoenix App

# install the generator
$ mix archive.install hex phx_new 1.5.6

# generate the project
$ mix phx.new foobar

# cd into the directory
$ cd foobar

# create our database
$ mix ecto.create

# start the server
$ mix phx.server

# commit your code to git
$ git init && git commit -am 'Initial Commit'

Prod Configuration

You will have to adjust some prod configuration for our app to work on Gigalixir. Let's make the following adjustments to the config/prod.exs file.

  config :foobar, FoobarWeb.Endpoint,
-   url: [host: "example.com", port: 80],
+   url: [host: "your-app-name.gigalixirapp.com", port: 443],
-   cache_static_manifest: "priv/static/cache_manifest.json"
+   cache_static_manifest: "priv/static/cache_manifest.json",
+   force_ssl: [rewrite_on: [:x_forwarded_proto]]
 
+ config :foobar, Foobar.Repo,
+   ssl: true

Deploy to Gigalixir

# install gigalixir (using Homebrew)
$ brew tap gigalixir/brew && brew install gigalixir

# sign up for gigalixir
$ gigalixir signup

# log in to gigalixir
$ gigalixir login

# create the app
$ gigalixir create

# set up your buildpacks
$ echo "elixir_version=1.10.3" > elixir_buildpack.config
$ echo "erlang_version=22.3" >> elixir_buildpack.config
$ echo "node_version=12.16.3" > phoenix_static_buildpack.config

# commit those changes
$ git commit -am 'Set up gigalixir buildpacks'

# create your prod database
$ gigalixir pg:create --free

# deploy your app
$ git push gigalixir main

# open your prod app
$ gigalixir open

Remote 1-on-1 meetings

Wed, 04 Nov 2020 09:10:38 +0000

From Posts on Claudio Ortolina:

In the last two years I've done hundreds of remote 1-on-1 meetings, both as a contributor talking to my manager(s) and as a manager talking to people in my team.

As a manager, I consider 1-on-1 meetings the most important responsibility I have: empowering other people to do their best work can greatly outmeasure any contribution I can give on my own.

What follows is some notes on what seems to work for me. It does not represent by any means a proper research on the matter, so please take it with a grain of salt.

Long term objectives

Regular 1-on-1 meetings can certainly be used to solve immediate, short-term blockers or clarify some questions, but the long term objective is building a working professional relationship where:

Both parties can safely be vulnerable and address deep issues that make day to day work more difficult. This can be anything from anxiety about the world at large, to having to homeschool kids, to difficulties in multitasking different responsibilities. Note that as a manager, you're allowed to show that you're struggling to the other person. We're human after all and that helps building transparent relationships. Needless to say, confidentiality and respect are paramount.
Trust takes time and effort. It may take months before people open up and start addressing important topics: what motivates them, problems they see in the team and in the company, their own aspirations and ultimately work on their professional growth.
Lead by example: if you ask a complex question (e.g. what do you wanna focus on this year?), answer it yourself first, so that they understand better.
Always prepare something to talk about: even if it seems artificial, it will gradually tune your perception to be on the lookout between meetings for topics to talk about and it will get easier. At the same time, if the other party doesn't provide topics over multiple meetings, make sure you address that. There's always something to talk about.

Preparation

Regular 1-on-1 meetings require preparation: the easiest thing to do to ease preparation is to keep an agenda document shared between the two participants.

I can recommend a shared Google Doc, with sections titled by date and sorted in reverse chronological order (most recent first).

This way you can:

Predictably add topics to discuss between meetings (it's always at the top).
Have implicit time tracking, i.e. you know when something was discussed.
Easily collaborate in real time during the meeting to capture ideas in a form that correctly reflects the other person's thoughts.

This system is by no means perfect (especially if you end up having dozens of these documents), but it's flexible enough that you can adapt it to individual preferences. For example, I find that with some people we can use the agenda to discuss topic asynchronously in writing beforehand (and draw some conclusions in the meeting), while with other we defer discussion to the meeting itself. With other ones, we end up adding topics during the meeting as the conversation naturally goes in different directions.

In addition, it's important to prepare for the conversation, even for just 5-10 minutes before the meeting. Having such time buffer not only helps clarifying thoughts beforehand, but also gives you an opportunity to stop thinking about what you were doing before and what you're gonna be doing after the meeting.

During the meeting

Respect the agenda as much as you can, making sure that you either address all points on it or explicitly say "We'll need to address this in a separate call. Can it wait our next planned session or do you wanna schedule an earlier follow-up?".
If the conversation drifts to a completely different direction and time is running tight, make sure both parties are happy to discuss that direction at the expense of other topics. You always have the option to capture the new topic and address it at a later stage.
Be at ease in saying "I don't know, but here's how I plan to find out and here's when I'm gonna report back about it". At the end of the day, trust is built on transparency and predictability.
When the other person explains something to you and you wanna make sure you got it right, repeat it back and ask for confirmation. By doing that, you both check your understanding and implicitly ask the other person to check their own explanation. I've used this technique in all sorts of other conversations in my professional and personal life and it does absolute wonders in clarifying expectations on both sides.
If you take notes, learn how to do that quickly by using keywords, then fill in the blanks later (and ask for confirmation to the other person once done). Writing can break the flow of the conversation, so it needs to be done carefully in order to minimize its impact.
If a conversation topic implies someone taking an action, explicitly state that in the form of "I will" or "You will" or "Someone else will", with an indication of when that would happen.
If the meeting resulted in some actions, recap them at the end of the call.
Video conversations have a different pace - let people speak, listen carefully, slow down, repeat a few times if needed.
Explicitly ask the other person if they think a topic has been exhausted before moving on.
Respectfully ask the other person how they're doing, leaving them space to decide what they can comfortably share with you. Do no pry and always qualify your questions with the reason why you're asking them. For example, I've been recently asking people how they're dealing with the COVID-19 pandemic, because I noticed erratic working patterns that suggest they may be working too much (for many people, work is much simpler to deal with, so they end up using it as a safe haven - I'm not a psychologist though so this is another thing to take with a grain of salt).
Provide context: while this is important in any company, I believe it's fundamental in a remote company because people have more limited opportunities to gather context by casually taking part to unscheduled conversations. So if I'm discussing a specific project that I think it's connected to other projects, I'll share that. More often than not, the person on the other end will appreciate the additional information and will make good use of it.

After the meeting

If you have any action, just do it as early as possible. Your ability to follow up is by far the most important factor in building trust. If the other person asks you to do something, you agree to it and you don't, they will not ask you again.

If at any point you realize you didn't do something you promised to do, acknowledge your shortcoming, apologize and make up for it. It happens, and if you're transparent about it usually the other person will understand.

Topics

1-on-1 meetings are structured around the people involved: while you can definitely start from some guideline questions, they should over time develop into a unique conversation.

That said, over the course of multiple meetings you should aim at:

Unblocking specific issue related to current streams of work, e.g. "I'm undecided on how to build X, if using this or that."
Clarify responsibilities, e.g. "Yes, you need to take care of X, while Alice can take care of Y."
Provide feedback on work done, e.g. "I really liked how you did X because…" or "I'd like to speak about Y, as there's an opportunity to improve Z."
Useful things to learn about, e.g. "As you're working on X, you might enjoy learning about Y."
Connect the dots with other projects, e.g. "As you're working on X, you might be interested to speak to Alice, as she's working on Y, which is related to X as…"
Happiness, satisfaction, and future work e.g. "If we look at the roadmap, there's X, Y, Z. Do they interest you? Which one would be your initial preference to work on?"

One important aspect is balance: too often 1-on-1 meetings are focused on the day to day work and don't cover the larger picture. This is why there should be scheduled Feedback Sessions where you go through some meta-questions that allow expanding scope.

These are some examples of questions useful for those sessions:

Are you happy about the work you're doing? Is it satisfactory?
Looking at X time period, can you point out a piece of your work you're proud of?
Looking at the same time period, can you point out 3 team achievements you're proud of?
What should the team focus on in this quarter?
If you had a magic wand and could instantly change anything in the team, what would that be?

In general, Feedback Sessions are an opportunity to look at the larger picture and think about the future. For more inspiration, you can consult the Small Improvements guide to 1-on-1 meetings.

Conclusions

As mentioned before, this is by no means an exhaustive guide, but a collection on thoughts based on my experience. At the end of the day, if you always focus on listening to the other person and acting swiftly on their feedback, you will get good results.

A Short Profiling Story

Tue, 03 Nov 2020 11:42:42 +0000

From Posts on Claudio Ortolina:

While transcribing the talk I gave at the last ElixirConf.eu conference, one of my colleagues pointed out that I glossed over the details of one of the examples. This prompted me to do some digging and I want to share what I found.

The problem

The example in question is a module responsible to fetch a file from a remote source and write it at the specified path.

The implementation is very simplistic and lacks both error handling and retry logic.

 defmodule Perils.Examples.Store do
 def write(file_name, url) do
 with {:ok, data} <- get(url) do
 File.write!(file_name, data)
 end
 end

 defp get(url) do
 :httpc.request(:get, {String.to_charlist(url), []}, [], [])
 |> case do
 {:ok, result} ->
 {{_, 200, _}, _headers, body} = result
 {:ok, body}

 error ->
 error
 end
 end
 end

Looking at the code, we can see that it relies on :httpc, the http client that ships with Erlang/OTP.

Both in my talk and in the initial transcription draft, I pointed out that running this code with a 12MB file would result in a memory usage peak at around 350/375MB, but didn't really look into why.

Such delta between the file size and peak memory usage is suspicious and worth investigating.

The investigation

I started by setting up an exprof test, so that I could profile resource usage associated with the problematic function.

 defmodule A do
 import ExProf.Macro

 def run(url) do
 profile do
 Perils.Examples.Store.write("magazine.pdf", url)
 end
 end
 end

 url = "https://web-examples.pspdfkit.com/magazine/example.pdf" #12MB
 {records, _block_result} = A.run(url)
 total_percent = Enum.reduce(records, 0.0, &(&1.percent + &2))
 IO.inspect("total = #{total_percent}")

The result (with some lines omitted) shows that most of the time (51.74%) is spent converting the binary response body to a list inside the maybe_format_body/2 function:

 FUNCTION CALLS % TIME [uS / CALLS]
 -------- ----- ------- ---- [----------]
 <omitted>
 erlang:iolist_to_binary/1 1 20.46 49705 [ 49705.00]
 erlang:binary_to_list/1 1 27.54 66887 [ 66887.00]
 httpc:maybe_format_body/2 1 51.74 125664 [ 125664.00]

While this is not an indication of higher memory usage per se, it's a good lead: binary to list conversion can be memory intensive.

I then looked at the source for maybe_format_body/2, making sure to match on the OTP version I tested against (23.1.1).

 maybe_format_body(BinBody, Options) ->
 case proplists:get_value(body_format, Options, string) of
 string ->
 binary_to_list(BinBody);
 _ ->
 BinBody
 end.

As expected, the function uses binary_to_list/1 to transform the response binary body into a list. Luckily, this behaviour can be tweaked via the body_format option, which defaults to string (as in Erlang string, which maps to a character list in Elixir).

Searching for body_format in the Erlang docs for request/5 shows that indeed it's possible to tweak our problematic implementation to:

 :httpc.request(:get, {String.to_charlist(url), []}, [], body_format: :binary)

With this change, memory usage decreases dramatically, showing a delta only slightly larger than the file size.

Conclusion

This whole investigation got me thinking, as the body_format option had been in the docs all along, yet I hadn't seen it. I can find three reasons:

The overall logic in the example doesn't really care about the response body contents, as it just writes them to a file. Without seeing that response, there was no way for me to even notice its type.
File.write/2 accepts binaries, strings and character lists - again I didn't have a reason to even wonder about the type used to represent that returned response body.
Working primarily in Elixir, everything tends to be either a string or a binary. I just "forget" that character lists exist, which lead to the implicit assumption that this would be the default for :httpc.

In other words, I didn't know what to search in the docs. Profiling tools helped me understand the problem space and pointed me in the right direction.

The BEAM marches forward

Mon, 26 Oct 2020 09:00:00 +0000

From Underjord.io: The BEAM is the virtual machine that Erlang and Elixir runs on. It is widely cited as a battle-tested piece of software though I don’t know in which wars it has seen action. It has definitely paid its dues in the telecom space as well as globally scaled projects such as Whatsapp and Discord. It is well suited to tackle soft-realtime distributed systems with heavy concurrency. It has been a good platform chugging along.

Supervision trees, an example in Elixir

Wed, 21 Oct 2020 07:00:00 +0000

From Underjord.io: So any time recently that I’ve gone looking for a good overview of supervision trees in Elixir I haven’t found what I want. I’m pretty sure I used to find some that covered making simple supervisors and workers without assuming you want a module for each Supervisor. I now believe those were following ye olde Supervisor.Spec which had helpers for that. How to make a module based Supervisor is in the docs so I won’t be spending time on that.

Stupid solutions: Live server push without JS

Fri, 25 Sep 2020 17:00:00 +0000

From Underjord.io: So in my post Is this evil? I covered a way of tracking users with CSS. While thinking about those weird ways of using the web I also started thinking about pushing live data to clients without JS. Or at least maintaining a connection. So WebSockets requires JS. WebRTC requires JS. Even HLS (video streaming), which would otherwise be super cool, with captions for accessibility. But no. Or rather, maybe on Apple platforms.

Vlog - 2020-09-22 - Helping Junior Developers

Tue, 22 Sep 2020 15:45:00 +0000

From Underjord.io: Pondering one of the things I want to make an impact in: helping inexperienced developers get the traction they need to find their way into the industry. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 Sorry, your browser doesn't support embedded videos.

Absinthe subscriptions with ReasonML and Urql

Mon, 21 Sep 2020 09:08:54 +0100

From Maarten van Vliet: Lately I’ve been looking into ReasonML as a language to pick up. In the past I’ve dabbled with Elm and really enjoyed it but it’s lack of interoperability with javascript hampers its development. ReasonML offers a far better story in this regards, there are excellent React and React-Native libraries/bindings available as well as bindings for popular Graphql clients. That, combinated with great type-safety makes it a compelling alternative to Elm and Typescript.

Vlog - 2020-09-17

Thu, 17 Sep 2020 15:45:00 +0000

From Underjord.io: A brief weekly run-down of what I've been doing. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 Sorry, your browser doesn't support embedded videos.

Is this evil?

Tue, 15 Sep 2020 14:00:01 +0000

From Underjord.io: I try to be a friendly citizen of the web. I try to keep my site in good shape. It should load quickly, track nothing beyond your basic server logs, not hassle you about cookies, GDPR or my newsletter. I do have a newsletter but it won't pop up in your face here. I try to stay firmly on the side of friendly and a good experience in how I run this site.

Vlog - 2020-09-07

Tue, 08 Sep 2020 08:00:00 +0000

From Underjord.io: A brief weekly run-down of what I've been doing and what I'm planning on doing. function switch_video(element) { var src = element.getAttribute("href"); var video = element.parentElement.querySelector("video"); var sources = video.querySelector("source"); video.pause(); sources.setAttribute("src", src); video.load(); video.play(); return false; } 4K HD 720 Sorry, your browser doesn't support embedded videos.

Vlog - 2020-09-07

Tue, 08 Sep 2020 08:00:00 +0000

Nerves-keyboard - Running a mechanical keyboard with Elixir

Tue, 01 Sep 2020 09:15:00 +0000

From Underjord.io: Chris Dosé was interviewed by us on Elixir Mix. When he spoke about his work on a Nerves-powered keyboard I knew this was a project I wanted to try out. So I dropped into their dev channel, acquired the hardware (thanks for the help) and have done some playing around with it. So what is the draw of a Nerves keyboard? Well, you can program it in Elixir. That's a big one for me personally.

Urql graphql subscriptions with Absinthe

Sat, 29 Aug 2020 11:08:54 +0100

From Maarten van Vliet: Many Graphql stacks use Apollo as the javascript client library. It’s well maintained, popular and has lot’s of examples. It also works together with Absinthe, the Elixir Graphql library. If you need to use graphql subscriptions in combination with Apollo and Absinthe there is the socket-apollo-link to connect the two. There’s another interesting javascript client library for Graphql on the horizon, Urql. It’s a bit more lightweight and looks really promising.

Simple Solutions: UI choices without JS

Wed, 26 Aug 2020 15:00:00 +0000

From Underjord.io: I've been looking at creating some progressively enhanced UI which shouldn't require JS for any basic operations. The idea being that I can accelerate and simplify any operation with interactivity provided by Javascript but I won't implement things in a way that requires JS. The demonstration below is one such example which can be used to give a very common type of interactivity without using Javascript. You can select an option or even expand a selection (similar method, but with a checkbox) without a line of Javascript.

Beam Bloggers Webring

Wed, 19 Aug 2020 08:00:00 +0000

From Underjord.io: This is a brief announcement. If you are interested in following bloggers in the BEAM, Elixir, Erlang, etc. ecosystem or you blog yourself. Please check out beambloggers.com to get in on the old-school webring action. Bloggers can join it. It might lead to some traffic. Mostly it is a small nod to a stranger old time on the web when sites organized in rings for discoverability. I think the need for discoverability remains and some webrings have been showing up again.

Dynamically Configure Your Plugs at Run-time

Tue, 18 Aug 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about the various ways that Plugs [1] can be dynamically configured, why you would need to configure your Plugs dynamically, and I also introduce two libraries that I wrote that attempt to solve a particular set of these problems. If you have been a reader of the blog for some time now, this post is a slight deviation from the usual in-depth project based tutorial that I usually present.

The Strong Technologies

Fri, 14 Aug 2020 09:30:00 +0000

From Underjord.io: I feel like a curmudgeonly sort recently. I'm honestly a pretty optimistic and positive person. But I'm becoming increasingly technically curmudgeonly. I don't think it is age turning me conservative. But I feel like I'm moving back to what I find tried and true in many ways. I feel resentful in a lot of cases where I can't really reasonably go back. So what am I talking about here?

Better Terminal Git Diffs

Wed, 12 Aug 2020 09:00:00 -04

From Mitchell Hanberg's Blog: Normally, our terminal git diffs look like this. ![ normal git diff ](https://res.cloudinary.com/mhanberg/image/upload/v1597177346/normal-git-diff.png){: .bg-transparent } Let's improve our experience by adding syntax highlighting! To accomplish this, we're going to replace the pager that git uses with a tool called [delta](https://github.com/dandavison/delta). Add the following to `~/.gitconfig`. ``` [core] pager = "delta" ``` Let's see what our git diffs look like now. ![git diff using delta as the pager](https://res.cloudinary.com/mhanberg/image/upload/v1597174958/git-diff-delta.png){: .bg-transparent} This looks great, but I think we can do even better. Let's configure `delta` to use the same theme as our terminal. `delta` uses [bat](https://github.com/sharkdp/bat/) for syntax highlighting, so we can use any theme that `bat` can use. Grab your theme (you'll have to find a TextMate/Sublime Text version of it), copy it into `~/.config/bat/themes`, and add the following option to your pager configuration. ``` [core] pager = "delta --theme='Forest Night'" ``` Now, the highlighting blends seamlessly with the rest of my development experience. ![git diff using delta as the pager](https://res.cloudinary.com/mhanberg/image/upload/v1597175033/delta-git-diff-with-theme.png){: .bg-transparent} One last improvement you can make is to use the same diff colors that your theme uses. I copied them from the theme file and added the following options to my pager configuration. ``` [core] pager = "delta --plus-color=\"#333B2F\" --minus-color=\"#382F32\" --theme='Forest Night'" ``` ![git diff using delta as the pager](https://res.cloudinary.com/mhanberg/image/upload/v1597175171/delta-git-diff-with-theme-with-diff-color.png){: .bg-transparent} Okay, now that our diffs look good, we can finally get back to work 😄.

Testing GenServers with Erlang Trace

Tue, 11 Aug 2020 01:07:11 GMT

From The Great Code Adventure: Thanks to lots of Googling and some help from a friend, I learned you can test that a GenServer received a message with the help of Erlang tracing.

The State of Elixir HTTP Clients

Mon, 10 Aug 2020 00:00:00 +0000

From My.Thoughts v1: This post was sponsored by the kind folks over at Check them out at https://appsignal.com In today’s post, we’ll learn about the Elixir HTTP client libraries Mint and Finch. We’ll discuss how Finch is built on top of Mint and what the benefits are of this abstraction layer. We’ll also talk about some of the existing HTTP client libraries in the ecosystem and discuss some of the things that make Mint and Finch different.

The best parts of Visual Studio Code are proprietary

Mon, 03 Aug 2020 07:25:00 +0000

From Underjord.io: I've been very surprised and delighted over a number of years now by Microsoft's strong efforts in open source. I understand the skeptics, I was on Slashdot when they tried to sue Linux out of existence and I think only time will tell. I figure MS contributing is better than them hunting Linux distributions for sport. So I was mostly onboard for Microsofts efforts and I've especially found Visual Studio Code useful.

OTP as the Core of Your Application Part 2

Wed, 29 Jul 2020 00:00:00 +0000

From My.Thoughts v1: Intro In OTP as the Core of Your Application Part 1 we covered what exactly the Actor Model is, how it is implemented in the Erlang Virtual machine (or BEAM for short), and some of the benefits of this kind of pattern. In the final part of this series, we’ll be implementing the Actor Model specific parts of our application, putting together a simple stress test tool, and comparing the performance characteristics of a traditional database centric application where every request is dependant on a round trip to the database.

Five Buck Fatigue

Thu, 23 Jul 2020 23:00:00 +0000

From Underjord.io: This is about a reaction I noticed with myself in response to membership programs, patreons and individual sponsorship as I've run into significantly more of these following Corona. The advertising-supported model has confirmed many of the concerns about its sustainability and creators are looking for more reliable options. I think this feeling I have might be something other people experience and something for creators to be prepared for. Creating anything in a sustainable fashion is hard work.

Inspect Yourself Before You Wreck Yourself

Sun, 19 Jul 2020 04:40:32 GMT

OTP as the Core of Your Application Part 1

Tue, 30 Jun 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this two part series, we’ll be taking a deep dive into what exactly the Actor Model is, how exactly the Actor Model is implemented in Elixir/Erlang and how we can leverage this pattern in a pragmatic way from within our applications. To really understand these concepts, we will be writing a Phoenix application that relies on GenServers as the primary datasource that powers our business logic. In regards to our database, we will only be leveraging it as a means of persistent storage only when needed.

"More than one thing at a time"

Wed, 17 Jun 2020 17:45:00 +0000

From Underjord.io: On a recent Elixir Outlaws episode Chris Keathley told us all a nice story of the advantages of Elixir as opposed to Ruby. His frustration with Ruby and appreciation of how Elixir works resonate at the frequency of my own frustrations and joys. I believe my titular quote is accurate, that's one of the primary things he noted. How nice it is to use a runtime that can do more than one thing at a time.

The Repository Pattern, Ecto, and Database-less Testing

Tue, 02 Jun 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about what exactly the repository pattern is, how it applies to Ecto, and how you can go about testing your Ecto backed applications without using a database. We’ll play around with this concept by putting together a simple Elixir application that leverages Postgres during development. But, then we will write some tests that make use of a database-less mock Repo. Without further ado, let’s dive right into things!

Elixir and ETS Alchemy

Sat, 30 May 2020 04:40:32 GMT

Using Mnesia in your Elixir application

Mon, 25 May 2020 00:00:00 +0000

From My.Thoughts v1: This post was sponsored by the kind folks over at Check them out at https://appsignal.com Using Mnesia in an Elixir Application In today’s post we’ll be learning about what exactly Mnesia is, when you should reach for a tool like Mnesia, and some of the pros and cons of using using it. After covering the fundementals of Mnesia, we’ll dive right into a sample application where we will build an Elixir application that makes use of Mnesia as its database.

WordPress & the gross inefficiencies

Fri, 22 May 2020 12:00:00 +0000

From Underjord.io: My recent work with WordPress revived a frustration I built up while working with software from that era of the 2000's. Drupal, WordPress, Joomla and friends. Whenever you visit a page, the system will generate it from scratch. Note: WordPress gets to take the brunt of the focus here. But it just happens to be what I recently used that re-ignited these frustrations. I believe this approach remains the standard for Drupal, Joomla, Mediawiki and many, many others.

Maqbool on System and Application Architecture @ Elixir Wizards Podcast

Fri, 22 May 2020 05:02:07 GMT

From ⚡ Maqbool Khan:

The WordPress merging problem

Mon, 18 May 2020 14:00:00 +0000

From Underjord.io: WordPress is approximately the most popular CMS out there. I've worked with it plenty over the years, off and on, as clients, employers and others have needed websites. After a while every WordPress site has ended up feeling slightly sticky, icky and annoying to deal with in the longer run. So I don't really recommend it these days. It remains a popular choice. Because people don't ask me first which is probably reasonable.

A wall too tall - Nerves & k3s

Wed, 06 May 2020 23:00:00 +0000

From Underjord.io: Short update on the general state of things. Pandemic quarantine in full swing. Me and mine are doing fine. Thankfully. We are staying at home awaiting a baby. I'm likely to be fairly sporadic for a few months. But I do intend to keep writing. Most of my blog posts are written to be useful in the longer term. If you want more in-the-moment writing, the newsletter is more temporally anchored publication (signup further down, no pop-up).

Getting started with Phoenix LiveDashboard

Mon, 04 May 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about what exactly Phoenix LiveDashboard [1] is, what you gain by using it, and my opinions on when/how you should use Phoenix LiveDashboard. Finally, we’ll set up a Phoenix application that makes use of Phoenix LiveDashboard and we’ll also put together a simple load testing script to exercise the application a bit. Without further ado, let’s dive right into things! What is Phoenix LiveDashboard?

We're All Project Managers Now

Tue, 21 Apr 2020 11:29:05 GMT

From The Great Code Adventure: Engineers thinking like project managers makes for higher performing teams, whether you're remote and async or not.

Self-evaluation improvements

Tue, 21 Apr 2020 06:15:00 +0000

From Underjord.io: A little while back I released a tool for self-evaluating as a web developer. I have just now updated it to include some explanation and guidance for things topics where the learner indicates a need for it. You can try it for yourself at Web Development - Self-evaluation. It is centered on inexperienced developers. It might be of some benefit to old dogs that need to remind themselves about tricks forgotten as well.

Check yourself - Web developer self-evaluation

Wed, 08 Apr 2020 06:30:00 +0000

From Underjord.io: I've been thinking a lot about inexperienced (junior, if you must) web developers and just how much there is to learn about programming in general but the web in particular. You often hear people say that you don't need to know everything but you should have a solid foundation. Well, how do you establish a solid foundation and how do you know if you have one? How do you get introduced to all the relevant terminology and how do you find out what you haven't learned yet?

How to Use gRPC in Elixir

Tue, 31 Mar 2020 00:00:00 +0000

From My.Thoughts v1: This post was sponsored by the kind folks over at Check them out at https://appsignal.com How to use gRPC in Elixir In today’s post, we’ll learn what gRPC is, when you should reach for such a tool, and some of the pros and cons of using it. After going over an introduction of gRPC, we’ll dive right into a sample application where we’ll build an Elixir backend API powered by gRPC.

Synchronizing Go Routines with Channels and WaitGroups

Fri, 27 Mar 2020 22:13:49 GMT

From The Great Code Adventure: In debugging a mysteriously hanging Go function recently, I learned something new about how to use WaitGroups and Channels to synchronize Go routines. Keep reading to learn more!

Structured logging in Elixir using Loki

Tue, 10 Mar 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about what exactly logging is, and how it differs from monitoring. We’ll also cover some best practices that should be considered when logging from within your application. In addition, we’ll cover the differences between structured and unstructured logs. And finally we’ll set up a simple Phoenix application backed by Postgres and run Loki along side it to collect all of our application logs.

I always want to do it all

Mon, 09 Mar 2020 06:00:00 +0000

From Underjord.io: My brain has very little chill on a day-to-day basis. There are moments where I can find a very peaceful state of mind. Doing something menial in the garden for an extended time, cooling off outside after a while in a sauna, winding down after heavy exercise. At most other times my mind is usually working on something or I'm itching with the need to do things. I've had to do a lot of pacing myself recently.

CI/CD with Phoenix, GitHub Actions, and Gigalixir

Tue, 03 Mar 2020 09:00:00 EST

From Mitchell Hanberg's Blog:

I like to start my side projects by immediately configuring them with a CI pipeline and automatic deployments. I normally go with Heroku, but Heroku has some drawbacks when deploying Elixir applications.

Luckily, another PaaS solution exists and is designed specifically for Elixir, Gigalixir! Let's build a project called "Pipsqueak" and learn how to automatically test and deploy a new Phoenix application to Gigalixir.

Note: This article will assume that you already know how to install Elixir/Erlang and will reference tools like hub that I actually used while implementing the application that I describe below.

Create a new Phoenix project

Our first step is to create a new Phoenix application. We'll then immediately initialize our git repository and push it up to GitHub.

I like to make the first commit right after generating the project so you don't get lost when making your initial changes. This way, when you look at the second commit, you'll see the first changes that the developer made.

$ mix phx.new pipsqueak && cd pipsqueak

$ git add . && git commit -m "Initial Commit"

$ hub create

$ git push -u origin master

Switch to Yarn

I like to use Yarn instead of NPM to manage my JavaScript packages, so we'll re-install the packages using Yarn to create our yarn.lock file.

If you don't use Yarn, you can skip this step.

$ rm assets/package-lock.json

$ (cd assets && yarn install)

$ git add . && git commit -m "Switch to Yarn"

Continuous Integration with GitHub Actions

GitHub Actions is a new product by GitHub that is used to run arbitrary workflows and CI pipelines in response to events emitted by GitHub. Let's run our new test suite by implementing a Workflow.

Our workflow will run on every push, check that our code is formatted, and run our test suite.

Notable pieces of this workflow are:

We use the matrix strategy even though we are only using a single combination. This way we can use our version in our cache keys, so that we update cache will invalidate when we inevitably update our language versions.
We boot up our Postgres server as a service container. Make sure the user/password/db match your application's test config.
We cache our Elixir and JavaScript dependencies so that we only install them if we really have to.
We cache our Elixir build so that the compiler only has to compile the files that have changed.

# .github/workflows/verify.yml

on: push

jobs:
  verify:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        otp: [22.2.7]
        elixir: [1.10.1]

    services:
      db:
        image: postgres:12
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: pipsqueak_test
        ports: ['5432:5432']
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5

    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-elixir@v1
        with:
          otp-version: ${{ matrix.otp }}
          elixir-version: ${{ matrix.elixir }}

      - name: Setup Node
        uses: actions/setup-node@v1
        with:
          node-version: 13.8.0

      - uses: actions/cache@v1
        id: deps-cache
        with:
          path: deps
          key: ${{ runner.os }}-mix-${{ hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}

      - uses: actions/cache@v1
        id: build-cache
        with:
          path: _build
          key: ${{ runner.os }}-build-${{ matrix.otp }}-${{ matrix.elixir }}-${{ hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}

      - name: Find yarn cache location
        id: yarn-cache
        run: echo "::set-output name=dir::$(yarn cache dir)"

      - uses: actions/cache@v1
        with:
          path: ${{ steps.yarn-cache.outputs.dir }}
          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
          restore-keys: |
            ${{ runner.os }}-yarn-

      - name: Install deps
        run: |
          mix deps.get
          (cd assets && yarn)

      - run: mix format --check-formatted
      - run: mix test{% endraw %}

To test our workflow, let's commit and push to GitHub.

$ git add . && git commit -m "Verify workflow"

$ git push origin master

Create a new Gigalixir app

Before proceeding with this section, please refer to the Gigalixir Getting Started Guide to create an account and install the gigalixir command line tool.

Our application will deploy using mix releases, so we need to add a config/releases.exs file. Gigalixir will detect this file and assume we are using a mix release.

The following will ensure that our server is started and URLs will be properly constructed.

# config/releases.exs

import Config

config :pipsqueak, PipsqueakWeb.Endpoint,
  server: true,
  http: [port: {:system, "PORT"}],
  url: [host: System.get_env("APP_NAME") <> ".gigalixirapp.com", port: 443]

Next, let's configure the Elixir, Erlang, Node, and Yarn versions to be used with our deployment. We'll use the latest version that are available at the time of writing.

Create the following files in the root of repository.

# elixir_buildpack.config

elixir_version=1.10.2
erlang_version=22.2.8

# phoenix_static_buildpack.config

node_version=13.8.0
yarn_version=1.22.0

Time to commit the changes we've made.

$ git add . && git commit -m "Configure for Gigalixir"

Before we can deploy our application, we'll have to create an app and a database using the gigalixir command line tool.

$ gigalixir create

$ gigalixir pg:create --free

Now we have somewhere to deploy our code. Like Heroku, Gigalixir uses git for deployments. Running gigalixir create added a git remote named gigalixir and now we can push to it.

$ git push gigalixir master

You should now be able to visit <your app name>.gigalixirapp.com and see our stock Phoenix application!

While this is quick and easy when first starting out, it can be tedious and error prone in the long run.

This is where Gigalixir falls short compared to Heroku. Heroku connects to GitHub and automatically deploys when all of your checks have passed. Checks are GitHub integrations that run some sort of test on your code and then either pass or fail.

Since we're using GitHub Actions, we have an entire marketplace of actions at our disposal. I saw that there wasn't an existing action for Gigalixir, so I decided to write my own!

Gigalixir Action

Check out the source code for this action here.

This action has a few features:

Deploy our application to Gigalixir.
Run our migrations upon a successful deployment.
If our migrations fail, it will rollback our deployment to the last version.

Running migrations requires ssh access to the deployment, so before we can get started we need to generate a new public/private key pair, upload the public key to Gigalixir, and add the private key to GitHub as a secret.

Let's generate an SSH key pair (without a passphrase) called gigalixir_rsa in our current directory and add it to Gigalixir.

$ ssh-keygen -t rsa -b 4096 -C "Gigalixir SSH Key"

$ gigalixir account:ssh_keys:add "$(cat gigalixir_rsa.pub)"

$ cat gigalixir_rsa | pbcopy

We also copied our private key to the clipboard so that we can add it as a GitHub secret.

We also need to need to add our GIGALIXIR_USERNAME and GIGALIXIR_PASSWORD as secrets in the same way we added the SSH_PRIVATE_KEY.

For now you can use the same account that you used to create the app, but in the future you should create a separate user for added security.

We can now configure the gigalixir-action to deploy our code.

{% raw %}# .github/workflows/verify.yml

jobs: 
  verify:
    ...

  deploy:
    # only run this job if the verify job succeeds
    needs: verify

    # only run this job if the workflow is running on the master branch
    if: github.ref == 'refs/heads/master'

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
        
        # actions/checkout@v2 only checks out the latest commit,
        # so we need to tell it to check out the entire master branch
        with:
          ref: master
          fetch-depth: 0

      # configure the gigalixir-actions with our credentials and app name
      - uses: mhanberg/gigalixir-action@v0.1.0
        with:
          GIGALIXIR_USERNAME: ${{ secrets.GIGALIXIR_USERNAME }}
          GIGALIXIR_PASSWORD: ${{ secrets.GIGALIXIR_PASSWORD }}
          GIGALIXIR_APP: <your app name>
          SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}{% endraw %}

Now all we have to do is commit and push our code!

$ git add . && git commit -m "Automatically deploy to Gigalixir"

What's next?

Now there's nothing holding you back from moving forward with your next project 😄.

If this article has helped you deploy your latest project, please let me know on Twitter!

My Long Distance Relationship With GitHub

Mon, 02 Mar 2020 12:56:07 GMT

From The Great Code Adventure: Coming up on my one month 💖 anniversary 💖 of joining the GitHub engineering organization, I'm reflecting on the challenges and benefits of remote, asynchronous teams.

Setting up my new computer

Mon, 02 Mar 2020 09:00:00 EST

From Mitchell Hanberg's Blog:

I started a new job last week, so I naturally received a new computer that required some set up.

Usually this could take hours or even days, as there's always an app I forget to download or some random setting that I can't remember how to configure.

Luckily, I have automated most of the process! In my dotfiles repository, I wrote (some parts borrowed) a shell script to install all of my CLI and GUI tools for me, as well as configure my shell environment.

Installing everything still took at least an hour (the bulk of this is due to brew compiling packages from source), but at least I am able to do it by running only a few shell commands!

My Process

Create a new ssh key and upload the public key to my Github profile.
Install the Xcode Command Line Tools (xcode-select --install). This is necessary to be able to use git.
Clone my dotfiles into my home directory git clone git@github.com:mhanberg/.dotfiles.git && cd .dotfiles
Run the install script ./install
Watch as my computer magically bootstraps itself 😄.

This is all made possible by Homebrew and rcm.

./install

The install script installs Homebrew and then runs the command brew bundle. The bundle subcommand will install every package that is declared in the Brewfile that is located in the root of my dotfiles.

An awesome thing about Homebrew is that it can install GUI tools (Firefox, Postico, Slack) in addition to CLI developer tools.

You can hand-craft a Brewfile or generate one based on the current packages and casks you have installed using brew bundle dump.

So far I haven't found a good way to keep my Brewfile up to date. I think that there might be a way to hook into your shell to print a message every time you install something using brew install.

The script then switches the default shell to the zsh that is installed by brew (if it isn't already). zsh is the default shell on macOS now, but if you want to use the newest releases you'll want to install via brew.

#! /usr/bin/env bash

set -e

if ! command -v brew >/dev/null; then
  echo "==> Installing Homebrew ..."
  if [[ "$OSTYPE" = darwin* ]]; then
    curl -fsS 'https://raw.githubusercontent.com/Homebrew/install/master/install' | ruby
  else
    curl -fsSL 'https://raw.githubusercontent.com/Linuxbrew/install/master/install.sh' | sh -c
  fi
fi

echo "==> Install Homebrew dependencies"
brew bundle

update_shell() {
  local shell_path;
  shell_path="$(command -v zsh)"

  echo "==> Changing your shell to zsh ..."
  if ! grep "$shell_path" /etc/shells > /dev/null 2>&1 ; then
    echo "==> Adding '$shell_path' to /etc/shells"
    sudo sh -c "echo $shell_path >> /etc/shells"
  fi
  sudo chsh -s "$shell_path" "$USER"
}

case "$SHELL" in
  */zsh)
    if [ "$(command -v zsh)" != '/usr/local/bin/zsh' ] ; then
      echo "==> Updating shell to ZSH"
      update_shell
    fi
    ;;
  *)
    echo "==> Updating shell to ZSH"
    update_shell
    ;;
esac

./rcup

./rcup

And finally, we run my rcup wrapper script. This calls the rcup utility included with rcm, with a few options that I want to always use, such as ignoring certain files.

rcm is a set of utilities that help manage your dotfiles using symlinks. When I call rcup, it will make symlinks in my home directory for any files (other than those I tell it to ignore) in ~/.dotfiles.

When adding a new dotfile, I can either create it in my home directory and call mkrc .my-new-dotfile or I can create it in ~/dotfiles/ and run ~/.dotfiles/rcup once more.

#! /usr/bin/env bash

set -e

echo "==> Installing dotfiles"
rcup -U Brewfile -x README.md -x mitch-preonic.json -x install -x rcup -v

Room for improvement

My install script automates most things, but there are still some places optimize.

Automate the manual steps with a "curl to bash" script that installs XCode and clones my dotfiles. e.g. curl https://raw.githubusercontent.com/mhanberg/.dotfiles/master/bootstrap.sh | bash.
Create a new ssh key.
Configure macOS specific settings like key repeat speed, dock size/behavior, etc.
Install my zsh plugins with zplug.

Boring is the new Black

Wed, 26 Feb 2020 10:39:45 GMT

From Bits of Code - Pieces of Writing: In this article I will explain why I believe that boring - yet pragmatic - choices are often the most powerful.

Getting your Elixir application ready for CI/CD

Mon, 10 Feb 2020 00:00:00 +0000

From My.Thoughts v1: This post was sponsored by the kind folks over at Check them out at https://appsignal.com In today’s post we’ll be going over what exactly continuous integration and continuous delivery are, the benefits that come along with employing CI/CD, and some best practices that you should follow. In addition, we’ll also explore a wide array of Elixir ecosystem tools that can help you to create top notch CI pipelines. In order to experiment with a handful of the tools that we will be discussing, we will use a Git hooks Elixir library to execute our CI/CD validation steps, but on our local machine.

Building Concurrent Workflows in Go with Goroutines and Channels

Mon, 27 Jan 2020 01:19:55 GMT

From The Great Code Adventure: Using goroutines and channels, we can ensure that our program works on on more than one task in a given time period. In this post, we'll use goroutines, channels and WaitGroups to process a "bulk user registration" request.

Lumen - Elixir & Erlang in the browser

Thu, 23 Jan 2020 23:59:00 +0000

From Underjord.io: 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. Note: This guide is outdated. These instructions will not work. Lumen is at the time of this update (2020-12-10) a moving target with an early release out. I plan on making an updated post at some point but will leave this post as it is.

Why am I still excited about Elixir?

Mon, 20 Jan 2020 21:30:00 +0000

From Underjord.io: A good ol' while back I wrote about why I'm interested in Elixir. I think that deserves some follow-up. So what's different? Well, I've worked a lot more with Elixir in a professional capacity since then. I've built more things in it both for work and play. I've also gone digging and written about it in weird and extensive ways that I hadn't expected. Professional work in Elixir I started working with a client that needed work done on an existing Elixir backend.

Debugging a Go Web App with VSCode and Delve

Fri, 17 Jan 2020 12:06:00 GMT

From The Great Code Adventure: I found that using Delve to debug a Golang web app was fairly non-intuitive. Keep reading to find out how its done!

Mocking HTTP Requests in Golang

Tue, 14 Jan 2020 15:52:37 GMT

From The Great Code Adventure: Let's take a look at how we can use interfaces to build a shared mock HTTP client that we can use across the test suite of our Golang app.

Ecto & Multi-tenancy - Prefixes - Part 3

Fri, 10 Jan 2020 13:00:00 +0000

From Underjord.io: This should be the final piece of this saga. Previous parts can be found here: Part 1 - Getting started Part 2 Now I'll cover the approach I finally ended up using. I had dynamic repos fully working but was somewhat haunted by the heavy-handed approach of running all those pools long before I knew anything about the loads I could expect for each tenant. I think it would work fine.

How to Use Broadway in Your Elixir Application

Tue, 07 Jan 2020 00:00:00 +0000

From My.Thoughts v1: This post was sponsored by the kind folks over at Check them out at https://appsignal.com How to Use Broadway in Your Elixir Application In today’s post, we will be covering the Elixir library Broadway. Broadway is a library which is maintained by the kind folks over at Plataformatec and allows us to create highly concurrent data processing pipelines with relative ease. After an overview of how Broadway works and when to use it, we’ll dive into a sample project where we leverage Broadway to fetch temperature data from https://openweathermap.

Easy and Robust Rate Limiting in Elixir

Tue, 07 Jan 2020 00:00:00 +0000

From My.Thoughts v1: Intro In this blog post, we’ll be talking about what rate limiters are, when they are applicable, and how we can write 2 styles of rate limiters leveraging GenServer, Erlang’s queue data structure, and Task.Supervisor. Finally, we’ll write a sample application that leverages a rate limiter and we’ll make our application modular in the sense that we can swap our rate limiters via configuration to achieve the operational characteristics that we desire.

A Slight Delight - Compile-time checking things

Mon, 06 Jan 2020 11:30:00 +0000

From Underjord.io: This was a short-but-sweet thing that struck me while working with a client code-base. It was trivial but both useful and delightful and it is a type of thing I haven't been able to do in Python, PHP and Javascript in quite the same way. Initially, the code was something like this: elixir defmodule MyApp.Schemas do alias ExJson.Schema def my_schema do %{ "properties" => %{ "email" => %{ "type": "string", }, "password" => %{ "type": "string", } } } |> Schema.

Building a MySQL Database Driver in Elixir @ Code BEAM Lite

Wed, 25 Dec 2019 05:28:33 GMT

From ⚡ Maqbool Khan: Have you ever wondered what happens beneath the covers when you talk to your Database? Well, you are in for a treat! In this talk, we are going to uncover the dark magic behind Database Drivers. We will look at everything that is needed to talk to a ...

Elixir - Signing for Cloudfront resources

Fri, 20 Dec 2019 10:00:00 +0000

From Underjord.io: This covers how to create Signed URL Custom Policies with Cloudfront in Elixir. If you are working with Elixir and AWS you are probably familiar with ExAws. If you are unfamiliar, let's cover some quick ground: AWS - Amazon's cloud offering, has a whole bunch of oddly named services. S3 - File storage on AWS. Cloudfront - CDN for AWS, useful for better delivery performance for files for example.

Happy little screens (with Elixir)

Mon, 16 Dec 2019 16:23:00 +0000

From Underjord.io: So me and Emilio Nyaray made Inky. We built on top of what was there from Nerves and Scenic and in the end we had the Inky series of eInk displays for Raspberry Pi devices working with Nerves through Elixir. Cool. That was a fun trip I've covered previously: Inky library release Getting started, guide The story of how it came together Me & Emilio spoke about it on Elixir Mix (podcast) Recently Frank Hunleth, Justin Schneck and Luis Gabriel Roldan (@groldan) who've all been involved in some display-related shenanigans of different sorts move their repos into our organization that we've used for Inky.

Broadway, RabbitMQ, and the Rise of Elixir Part 2

Thu, 05 Dec 2019 00:00:00 +0000

From My.Thoughts v1: Intro In Broadway, RabbitMQ, and the Rise of Elixir Part 1 we covered what exactly a message queue is and when it is appropriate to use one. We also put together the foundation for our application which will mine data from the HackerNews Firebase API. In the final part of this series, we will be setting up our Broadway pipelines, a GenServer that will generate IDs for us to process, and some database related modules that will allow us to persist our results for later analysis.

Broadway, RabbitMQ, and the Rise of Elixir Part 1

Sun, 10 Nov 2019 00:00:00 +0000

From My.Thoughts v1: Intro In this two part series we’ll be talking about what a message queue is and when you would use one in your application. From there we’ll dive into the Broadway library maintained by Plataformatec and see how it can be leveraged from within an application for data processing. Finally, we’ll create a sample project that makes use of RabbitMQ+Broadway to scrape comments from HackerNews so we can measure the popularity of Elixir over time.

Consider signing up for the Elixir Radar

Fri, 08 Nov 2019 06:00:00 +0000

From Underjord.io: Old page, kept to avoid 404.

Ecto & Multi-tenancy - Dynamic Repos - Part 2

Fri, 01 Nov 2019 07:00:00 +0000

From Underjord.io: In the first part I covered the basics of getting started with Dynamic repositories with Ecto. Using that post we can create one or more repos at runtime, create the necessary database, run migrations to get it ready and then direct queries to it. That's a good start. Building blocks for something better. I'll try to get into the better bits here. That said, I still ended up using prefixes because it made my code simpler.

I was on a podcast

Wed, 23 Oct 2019 06:00:00 +0000

From Underjord.io: You can listen to it here. Mark Ericksen of Elixir Mix got in touch and asked if I'd come on to talk about the things I've done with Inky, Elixir and Nerves. So I did. And I brought my co-conspirator Emilio with me. I thought the episode turned out well. I certainly enjoyed it and I haven't been on a podcast before. So thanks to my readers, the community and the Elixir Mix gang for the opportunity.

Ecto & Multi-tenancy - Dynamic Repos - Part 1 - Getting started

Mon, 14 Oct 2019 21:37:00 +0000

From Underjord.io: Ecto is the database library we know and love from the Elixir ecosystem. It is used by default in Phoenix, the high-profile web framework. Ecto has a bunch of cool features and ideas. But this post is about a corner full of nuts, bolts and very little of the shiny or hot stuff. It just covers some rather specific needs. Ecto docs for these features are this guide and this API.

How we improved our Elixir build speed by 5x

Tue, 08 Oct 2019 20:53:00 GMT

From Bits of Code - Pieces of Writing:

I’m really happy and proud to say that since this story was first posted, I received great feedback and relay throughout the Elixir community! The last advice given in this article has indeed been taken as an inspiration by José Valim to add a test partitioning feature

What I'm up to - Mostly Elixir things

Thu, 03 Oct 2019 11:00:00 +0000

From Underjord.io: While I'm writing something a bit more involved and substantial I figured I could give an update on what I've been doing. Mostly around Elixir. But I'll cover a few different things. Ecto - A deep dive Working on a project I'll cover more at a later date has led me to work more with Ecto. I rather like it. What I didn't like is that my use-case seems fairly unexplored and a little bit light on documentation.

Building Dynamic Outputs with Terraform Expressions and Functions

Wed, 18 Sep 2019 13:04:00 GMT

From The Great Code Adventure:

We know we can define a Terraform module that produces output for another module to use as input. But how can we build dynamic output from a module that creates a set resources, and format that output just right to act as input elsewhere? It's possible with the

Prometheus, PostGIS and Phoenix Part 2

Mon, 16 Sep 2019 00:00:00 +0000

From My.Thoughts v1: Intro In Prometheus, PostGIS and Phoenix Part 1 we covered what exactly monitoring is and what are its benefits. We also put together the foundation for our application that we will be monitoring with Prometheus and Grafana. In the final part of this series, we’ll be setting up our monitoring stack, instrumenting our application, and writing a simple stress tester to make our graphs dance. Part 2 assumes that you have already gone through Part 1 and have the code and database at a point where we can jump right in.

Publishex - publish static pages

Sun, 15 Sep 2019 23:04:18 +0200

From Maarten van Vliet: Publishex hex package Library easily publish static pages to S3 or Netlify

Why a newsletter?

Thu, 12 Sep 2019 08:56:00 +0000

From Underjord.io: What is it good for? Doing it wrong Simple tech Readership contact Resilience and sustainability So I'm launching a newsletter. The sign-up is at the bottom of the page, it won't pop up here, so read on in peace. What is it good for? Every tech blogger has a newsletter these days. How come? Because it works. Because it is bed-rock old-web stuff. It is relationship building, it is building a network, an audience and connections.

Knock Down Your House: Refactoring and The Creative Process

Wed, 11 Sep 2019 01:01:53 GMT

From The Great Code Adventure:

Recently, my team and I were tasked with the holy grail of assignments--a greenfield project. We were writing brand new code in a brand new app to meet brand new requirements. Like many developers, we jumped at this chance to design our own codebase and solve a new set of

Prometheus, PostGIS and Phoenix Part 1

Tue, 20 Aug 2019 00:00:00 +0000

From My.Thoughts v1: Intro In this two part series, we’ll talk about what exactly monitoring is and why you need it in your production application. We’ll also cover how monitoring differs from logging and some considerations that need to be made when selecting a monitoring solution. Finally we’ll go through setting up a monitoring stack alongside a sample Phoenix application. Without further ado, let’s dive right into things! What is monitoring? Monitoring is the process of collecting metrics from your applications, infrastructure, supporting services, and databases and then storing this data over time.

Case Study: Inky - An elixir library

Fri, 09 Aug 2019 14:00:00 +0000

From Underjord.io: This is a post covering the creation and refinement of an open source project within the Elixir ecosystem. More words than code. Be warned. I bought* a display from Pimoroni called the Inky PHAT, the red version. It is an eInk display. That means it can show an image even without power being supplied to the screen. In this case it can show black, white and red. It refreshes very slowly (12 seconds or more) but is a cool and potentially useful piece of tech.

Monitor Your Phoenix Application with Sentry

Fri, 19 Jul 2019 00:00:00 +0000

From My.Thoughts v1: Intro In this post we’ll talk about what what exactly error monitoring is, why you need it in your production application, and what tools are available in the space. Finally, we’ll go over setting up a self hosted error monitoring solution for a sample Phoenix application. Without further ado, let’s dive right into things! What is error monitoring? Error monitoring is the practice of monitoring your application for errors or unhandled exceptions.

Artisanal software - Beyond pragmatism

Mon, 15 Jul 2019 15:00:00 +0000

From Underjord.io: Whenever we design and create software we need to pay attention to the trade-offs we are making. When you make software for a business purpose within a company, the trade-offs are made in relation to business goals, available resources, the deadline and often office and team politics. Quite a few things come into play to shape what you are doing. And developers in these environments generally can't control all the trade-offs that are being made.

Serve Letsencrypt certificates dynamically for Plug/Phoenix

Fri, 12 Jul 2019 10:04:18 +0200

From Maarten van Vliet: Certbot hex package Serve Letsencrypt certificates dynamically for Plug/Phoenix

Introducing Temple: An elegant HTML library for Elixir and Phoenix

Fri, 12 Jul 2019 09:00:00 -04

From Mitchell Hanberg's Blog: Temple is a macro DSL for writing HTML markup in [Elixir](https://elixir-lang.org) and a template engine for [Phoenix](https://phoenixframework.org/). Conventional template languages like [EEx](https://hexdocs.pm/eex/EEx.html) 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. Let's take a look. ```elixir use Temple @items ["eggs", "milk", "bacon"] temple do h2 "todos" ul class: "list" do for item <- @items do li class: "item" do div class: "checkbox" do div class: "bullet hidden" end div item end end end script """ function toggleCheck({currentTarget}) { currentTarget.children[0].children[0].classList.toggle("hidden"); } let items = document.querySelectorAll("li"); Array.from(items).forEach(checkbox => checkbox.addEventListener("click", toggleCheck) ); """ end ``` ### Phoenix Template Engine By implementing the `Phoenix.Template.Engine` behaviour, Temple becomes a full fledged template engine. ```elixir # config/config.exs config :phoenix, :template_engines, exs: Temple.Engine ``` ```elixir # lib/blog_web.ex def view do quote do # ... use Temple end end ``` ```elixir # lib/blog_web/templates/post/show.html.exs h2 @post.title div do text "By #{Enum.join(@post.authors, ", ")}" end article do text @post.body end aside do for c <- @post.comments do div c.name div c.body end end ``` ### Phoenix.HTML All of the Phoenix form and link helpers have been wrapped to be compatible with Temple. The semantics and naming of some helpers have been change to work as macros and avoid name conflicts with standard HTML5 tags. ```elixir # takes a block and has access to the variable `form` form_for @post, Routes.post_path(@conn, :create) do # prefixed with `phx_` to avoid a conflict with the tag phx_label form, :title text_input form, :title phx_label form, :authors multiple_select form, :authors, @users phx_label form, :body text_area form, :body end ``` ### Components Temple offers [React-ish](https://reactjs.org) style API for extracting reusable components. `defcomponent` will define macros for you to use in your markup without them looking any different from normal tags. ```elixir # layout_view.ex defmodule MyAppWeb.LayoutView do use MyAppWeb, :view defcomponent :nav_item do div id: @id, class: "flex flex-col" do div @name, class: "margin-bottom-2" div @description end end end # app.html.exs html do head do # stuff end body do header do nav do for item <- @nav_items do nav_item id: item.key, name: item.name, description: item.description end end end main role: "main", class: "container" do p get_flash(@conn, :info), class: "alert alert-info", role: "alert" p get_flash(@conn, :error), class: "alert alert-danger", role: "alert" partial render(@view_module, @view_template, assigns) end end end ``` Components can also take children if passed a block and are accessed via the `@children` variable. ```elixir defcomponent :takes_children do div class: "some-wrapping-class" do @children end end takes_children do span do text "child one" end span do text "child two" end span do text "child three" end end #

# child one # child two # child three #

``` ## Wrapping up If you're interested in using Temple, you can install it from [Hex](https://hex.pm/packages/temple) and check it out on [GitHub](https://github.com/mhanberg/temple). Let me know what you think!

An eInk display with Nerves & Elixir - Getting started with Inky

Sun, 07 Jul 2019 18:10:00 +0000

From Underjord.io: So I've been curious about what kinds of displays you can connect to the Pi-series single board computers for a while. I happened to accidentally order a few. Among others an eInk display. I ordered the PaPiRus ePaper. It ended up being dead on arrival and then out of stock so I received an Inky to replace it. Fair enough. eInk, as you know, is cool because it doesn't need power to keep displaying whatever you made it display last.

Inky library released!

Thu, 04 Jul 2019 10:38:00 +0000

From Underjord.io: Me and nyaray finally finished up our work on the Inky eInk display library to a level where we are happy to release it. So Inky 1.0.0 is now out on Hex! Docs are on there too. This is a small library and what started as a simple almost line-by-line port of the Python library on my part is now testable and tested. It has a simulator for on-host development (separate library, inky_host_dev).

Revitalizing valuable legacy systems

Mon, 24 Jun 2019 11:00:00 +0000

From Underjord.io: Do you have a system that is vital to your business that your development team seems to have given up on? Do they consider it old, slow, complicated or impossible to work with? Are they pushing heavily for a rewrite? They are probably right. It has probably become old, slow and difficult to work with. And it might be fair that they are trying to sell you on a rewrite.

Multi-stage Docker Builds and Elixir 1.9 Releases

Thu, 20 Jun 2019 00:00:00 +0000

From My.Thoughts v1: Intro In this post we’ll talk about what a release is in the context of Elixir and why/when you should use it. We’ll also cover how this was performed historically and how this changes in Elixir 1.9. Finally we’ll go through creating an Elixir release inside of a Docker container using multi-stage builds. Without further ado, let’s dive right into things! What is a release? An Elixir release (and Erlang of course) is the process of taking your application and bundling it so that it is ready for distribution (generally called an OTP release).

Why am I interested in Elixir?

Tue, 11 Jun 2019 17:30:00 +0000

From Underjord.io: The juicy bits OTP & the BEAM Phoenix Presence Phoenix LiveView Nerves Scenic Rustler I’ve had Elixir on the brain recently. And by recently I probably mean 2 years. In my defense I think it is fair to say it is blooming right now. I haven’t had much need of it, or opportunity for it, in my day-to-day of maintaining a Python legacy system, renewing another legacy or optimizing Elasticsearch.

Open Source

Thu, 06 Jun 2019 16:56:55 -0400

From My.Thoughts v1: In addition to blogging, I also enjoy writing Elixir libraries in order to solve some of my day to day development problems. I publish those libraries to https://hex.pm/users/akoutmos and have the code freely available on my GitHub at https://github.com/akoutmos. Below are some of the projects that I currently maintain along with some details as to what they do. Feel free to leave feedback on GitHub if you encounter any issues or if there are any features that you would like to see!

Elixir Tips

Thu, 06 Jun 2019 16:56:55 -0400

From My.Thoughts v1: Since the summer of 2020 I have been publishing Elixir tips three times a week on Twitter. These are small and focused code snippets that show you some cool (and possibly lesser known) things about Elixir and tools from around the ecosystem. I found that I often needed to lookup some of my old tips for my own purposes and had a hard time tracking them down in my timeline.

About

Thu, 06 Jun 2019 16:56:55 -0400

From My.Thoughts v1: Hello and thanks for stopping by! My name is Alex Koutmos and I am the father of 2 beautiful girls and 1 shy dog. My wife and I enjoy taking our girls on hiking adventures and road trips. When I am not hanging out with my beautiful family, I enjoy fighting working with computers and cars. By day I am a software engineer, and by night I am a grease monkey.

Elixir and The Beam: How Concurrency Really Works

Thu, 23 May 2019 10:01:16 GMT

From The Great Code Adventure:

This post was originally published on the Flatiron Labs blog. Check it out here for more awesome content by The Flatiron School's technology team.

Elixir and The Beam: How Concurrency Really Works

Elixir has become famous as the shiny new “concurrent” programming language, with more and

Scenic - Getting started from scratch

Mon, 20 May 2019 18:00:00 +0000

From Underjord.io: This post covers setting up a Scenic project in the Elixir programming language. It briefly covers the default method but largely dives into adding Scenic to an existing project, which covers the different parts that Scenic requires to run. The official approach Requirements Elixir 18, OTP 21 (I recommend using asdf to install and use the right version) Scenic 0.10 (this is covered in the guide) A brand new project Scenic, the OpenGL-based and very tasty UI framework for Elixir (& friends) has a very reasonable project generator.

Using Recursive Common Table Expressions with Ecto

Thu, 02 May 2019 12:04:18 +0200

From Maarten van Vliet: A presentation I gave at the Amsterdam Elixir Meetup. We faced a problem where we needed to recursively load records from a database. The application was doing the recursion itself, recursively querying the mariadb instance. I explained how we moved to RCTE’s and how this works in Ecto. Slides

Elixir Test Mocking with Mox

Thu, 11 Apr 2019 09:47:19 GMT

From The Great Code Adventure:

Building an api client mock and learning to love mocks-as-nouns

This post was originally published on the Flatiron Labs blog, The Flatiron School Technology Team's blog. Check out more awesome Flatiron Labs posts here.

Why We Need Mox

In a recent post, we talked about the age-old question:

Implementing link following with OAuth

Sun, 07 Apr 2019 09:00:00 -04

From Mitchell Hanberg's Blog: **Link following** is the process for dynamically redirecting a user after successful authentication. Disclaimer: I'm not sure what this is actually called, so I made up "Link following." If you know the actual name, [let me know!](https://twitter.com/mitchhanberg) If you are new to using OAuth to handle authentication, implementing link following won't be as intuitive as it would be if you were hand rolling your own. The trouble comes with remembering the link that the user clicked. If you were to write your own auth, this would all be handled within your own application and it would be easy to maintain that state. With OAuth, authentication is actually split between your application and the OAuth service that you don't control. So how are you supposed to remember where the user wanted to go after the OAuth service authenticates the user? The OAuth protocol specifies a [state](https://auth0.com/docs/protocols/oauth2/oauth-state) parameter that can be sent along with the authentication request and is returned with the response. ## Implementation I recently implemented link following with the [Elixir](https://elixir-lang.org/) libraries [Phoenix](https://phoenixframework.org/) and [Ueberauth](https://github.com/ueberauth/ueberauth), but these principles apply to any language or library. When the request comes in, we need to determine if the user is logged in. If they aren't we will need to redirect them to the log in page and take note of the original request path. Let's define a plug to do this for us. (The code snippets here are stripped down for brevity) ```elixir defmodule MyAppWeb.LoggedIn do def call(conn, _opts) do case current_user(conn) do nil -> conn |> Phoenix.Controller.redirect(to: Routes.some_controller_path( conn, :login, path: conn.request_path ) ) |> halt() _ -> conn end end end ``` Now that we are sending the original request path along with the redirect to the login page, we'll want to use that information to form our OAuth link. ```elixir link( to: Routes.auth_path(conn, :request, "oauth service", state: path ) ) ``` If the user is able to authenticate with the OAuth service, we'll be able to take advantage of the state parameter that is sent back with the response in our controller action. The `User.find_or_create/1` function attempts to find an existing user and will create one if it can't, returning the user. `handle_find_for_create/2` will handle the response from the previous function, such as putting the user in the session and setting the flash message, returning the conn. `redirect/2` will send the user to their original destination based on the state parameter returned by the OAuth service. ```elixir def callback( %{assigns: %{ueberauth_auth: auth}} = conn, %{"state" => path} ) do conn = auth |> User.find_or_create() |> handle_find_or_create(conn) redirect conn, to: path end ``` ## Wrapping up The OAuth protocol takes a state parameter that allows you to maintain a piece of data during the authentication handshake, we can use this to remember what link the user was attempting to access, and redirect them after a successful handshake.

Tools I use for mobile web development

Thu, 04 Apr 2019 09:00:00 -04

From Mitchell Hanberg's Blog: It's never been easier to write web applications for mobile and I want to share some of the tools I use everyday that help me do so. ## ngrok [ngrok](https://ngrok.com/) is a tool used to create encrypted web tunnels to your computer in order to expose a local development server to the internet. While modern web browsers have "mobile mode" dev tools, they don't perform as well as actually using the app on your phone. My practice is to open the app on my phone and computer side by side, allowing me to make sure that the design looks great at all screen sizes. ## Live reload Live reloading typically involves a file watcher that triggers a browser refresh when files change on disk. Manually reloading the page is a pain, especially when you have your app open in multiple browsers and devices. Luckily, many web frameworks come with built-in live reloading functionality. The tools that I use often that provide this are [Jekyll](https://jekyllrb.com/) `jekyll serve --livereload` and the Elixir web framework [Phoenix](https://phoenixframework.org/) `iex -S mix phx.server` (it works without any extra options). ## Safari mobile web inspector I use the Mobile Safari dev tools to debug JavaScript and design in the browser when I'm running to problems with my applications on mobile. To use the Web Inspector on your iPhone, toggle the following option under Settings > Safari > Advanced and following the instructions. ![Picture of the web inspector option for the Safari web browser on iOS](/images/safari-web-inspector.jpg) ## Tailwind CSS My favorite tool for making mobile friendly applications is the [Tailwind CSS](https://tailwindcss.com/docs/what-is-tailwind/) utility-first CSS framework. Tailwind generates responsive versions of all of it's CSS classes and provides custom [at-rules](https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule) to help with writing your own. Here are a couple examples of responsive design using Tailwind. ```html

Developing for Mobile Efficiently

``` You can create your own responsive classes using the `@responsive` at-rule. ```css @responsive { .my-style { /* styles... */ } } ``` ## What else is out there? I'm always interested in finding new tools, so if you use something not mentioned here, please share it with me on Twitter! [@mitchhanberg](https://twitter.com/mitchhanberg)

Walk-Though of Phoenix Live View

Sun, 17 Mar 2019 20:32:00 GMT

From The Great Code Adventure:

It's here! Phoenix Live View leverages server-rendered HTML and Phoenix's native WebSocket tooling so you can build fancy real-time features without all that complicated JavaScript. If you're sick to death of writing JS (I had a bad day with Redux, don't ask)

Experiment in the REPL

Tue, 19 Feb 2019 11:00:00 EST

From Mitchell Hanberg's Blog:

A technique I've picked up for learning new tools is experimenting with them in the REPL.

A read–eval–print loop (REPL), is a simple, interactive computer programming environment that takes single user inputs, evaluates them, and returns the result to the user. *

Elixir (iex), Ruby (irb), and Node.js (node) all have interactive shells that allow you to evaluate expressions easily and quickly.

This works great for small things like remembering how division works or grokking a tricky enumerable method.

iex(1)> 1 / 2
0.5
iex(2)> div 1, 2
0
iex(3)> Enum.reject([1, 2, 3], fn n -> rem(n, 2) == 0 end)
[1, 3]

It's also a convenient way to try out new libraries.

iex(4)> Slack.Web.Chat.post_message("C68FV6MDH", nil, %{attachments: [%{color: "good", text: "Hello world!"}]})
** (ArgumentError) argument error
    :erlang.list_to_binary([%{color: "good", text: "Hello world!"}])
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_bstr.erl:36: :hackney_bstr.to_binary/1
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_url.erl:300: :hackney_url.urlencode/2
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_url.erl:360: :hackney_url.qs/3
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_request.erl:310: :hackney_request.encode_form/1
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_request.erl:318: :hackney_request.handle_body/4
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney_request.erl:81: :hackney_request.perform/2
    (hackney) /Users/mitchell/Development/my_app/deps/hackney/src/hackney.erl:373: :hackney.send_request/2
    (httpoison) lib/httpoison/base.ex:787: HTTPoison.Base.request/6
    (httpoison) lib/httpoison.ex:128: HTTPoison.request!/5
    (slack) lib/slack/web/web.ex:51: Slack.Web.Chat.post_message/3

# Turns out we need to JSON encode the attachments list
iex(5)>Slack.Web.Chat.post_message("C68FV6MDH", nil, %{attachments: Jason.encode!([%{color: "good", text: "Hello world!"}])})
%{
  "channel" => "C68FV6MDH",
  "ok" => true,
}

I find experimenting in the REPL to be useful when I need a short feedback loop that isn't tightly coupled to the full stack of my application.

Avoid Analysis Paralysis

Analysis paralysis is when the fear of potential error outweighs the realistic expectation or potential value of success, and this imbalance results in suppressed decision-making in an unconscious effort to preserve existing options. *

Idle hands build nothing. I fell into this trap recently, wasting hours before I remembered the power of the REPL.

I knew I needed to use either a Supervisor or a Dynamic Supervisor, but I wasn't sure which one was right for the job.

Unclear on how to proceed, I spent a few hours reading documentation, searching for blog posts, and asking people for advice. Did I learn enough to make a decision? No.

Then I spent 20 minutes experimenting with them in iex and I knew which one to use.

From Elixir School: TIL GenServer's `handle_continue/2`

Sat, 16 Feb 2019 12:39:23 GMT

From The Great Code Adventure:

This post was originally published on the Elixir School blog. Elixir School is an open source Elixir curriculum and we're looking for contributors! You can write a short TIL blog post, a longer blog post, add a lesson, help with translation and more. Check out our open issues

Tips for Reading More

Thu, 14 Feb 2019 13:30:00 EST

From Mitchell Hanberg's Blog:

In 2017, I challenged myself to read 20 books and I was able to read 22 books.

In 2018, I raised the bar to 30 books, but I was only able to read 16.

In 2019, I'm still aiming for 30 books; how can I make this happen?

So far in 2019 I've already read 7 books and have found good strategies for frequent and consistent reading.

I've started reading during boring activities that don't require my eyes. I read in bed when I'm struggling to fall asleep. I read in the morning when I'm riding my stationary bike. This is similar to the idea of listening to a podcast while driving to work.

I've started buying books in groups of three. Always having something in the queue decreases the number of times that I have to figure out what I'm going to read next.

I've started asking my friends for book recommendations. This decreases the risk of starting a bad book and relieves decision paralysis. I'll show the list of books I want to read to a friend and ask if they recommend anything on the list, essentially cross referencing my interests with their recommendations.

I've started sharing what I'm reading. When I make my three-book purchase, I share a screenshot on Twitter. This creates pseudo social pressure to finish and sharing it in the open helps solidify my identity as a "reader."

Creating Responsive Popovers with Popper.js

Mon, 11 Feb 2019 09:00:00 EST

From Mitchell Hanberg's Blog:

Making simple popovers is pretty easy.

Making popovers that position themselves based on the available screen real estate so they're always visible is not.

Luckily Popper.js will do the math for us and is straight forward to implement given the proper instructions.

JavaScript

The JavaScript portion is simple. The Popper constructor takes a DOM node to attach the popover to and a DOM node that will be the body of the popover.

// index.js

const attachmentNode = document.querySelector("#attachment-point");
const popoverNode = document.querySelector("#my-popover");

const myPopper = new Popper(attachmentNode, popoverNode);

HTML and CSS

The HTML and CSS is simple unless you want an arrow tab on your popover.

The docs make it seem like the arrow comes for free, but you'll have to implement it yourself.

<!-- index.html -->

<button id="attachment-point"> Open Sesame! </button>

<div class="popover" id="my-popover">
  <div x-arrow></div>

  <div>
    <!-- your popover content here -->
  </div>
</div>

Popper.js will look for an element with the x-arrow attribute to use for the arrow tab.

In order for the arrow to be on the correct side of the popover, we need to style it as described below.

/* styles.css */

[x-arrow] {
  position: absolute;
}

.popover {
  margin-top: 10px;
  margin-bottom: 10px;
}

.popover[x-placement="bottom"] [x-arrow] {
  top: -10px;
  border-bottom: 10px solid white;
  border-right: 10px solid transparent;
  border-left: 10px solid transparent;
}

.popover[x-placement="top"] [x-arrow] {
  bottom: -10px;
  border-top: 10px solid white;
  border-right: 10px solid transparent;
  border-left: 10px solid transparent;
}

The x-placement attribute added by Popper.js allows you to style the arrow based on the orientation of the popover.

The goofiness you see with the borders is a hack you can use to create a triangle using a div. I haven't tried it, but I imagine using an svg yields better results.

Wrapping Up

Popper.js takes care of the hard part so you can focus on building your application.

If you want the popover to show on click or hover, you'll have to add a little more JavaScript and CSS.

Hop into this Code Sandbox and give it a shot.

Using serverless Ruby on AWS Lambda to resize images

Fri, 04 Jan 2019 10:08:54 +0100

From Maarten van Vliet: At the last AWS ReInvent, it was announced that AWS Lambda would support Ruby as a runtime language. I was eager to try this out, Ruby’s powerful syntax and features are a joy to work with and coupling this with AWS Lambda I figured it could be leveraged for some easy image resizing Lambda. I started off with the serverless framework as this is an easy way provision Lambda functions. The goal is that when an image is uploaded to an S3 bucket, a Lambda is started, it resizes the image, and then uploads it to another bucket.

Absinthe SDL

Wed, 02 Jan 2019 12:04:18 +0200

From Maarten van Vliet: Absinthe SDL Create Graphql SDL schemas from Absinthe schemas

Writing your own Absinthe DSL with macros and middleware

Sat, 29 Dec 2018 11:08:54 +0100

From Maarten van Vliet: Absinthe is a great library to do graphql in Elixir. However, when writing your resolvers you may find that you are writing some boilerplate multiple times. So, in the spirit of keeping your code DRY, in this post I’ll show how we can leverage middleware and a macro to write your own DSL for your Graphql api. I assume some basic knowledge on how Absinthe works, most of the information can be found on in the guides

Receivex - incoming email webhook handler

Sat, 15 Dec 2018 23:04:18 +0200

From Maarten van Vliet: Receivex hex package Library to handle incoming email webhook from popular mail providers

Automatic Persisted Queries hex package

Sat, 01 Dec 2018 23:04:18 +0200

From Maarten van Vliet: APQ hex package Cache Apollo graphql queries automatically on Absinthe

Conducting Good Retrospectives

Fri, 09 Nov 2018 21:00:00 EST

From Mitchell Hanberg's Blog:

Every team experiences moments of success or failure, moments of working like a well oiled machine, and moments of not being able to stand the sound of each other's voices. But many teams let these moments pass by without taking time to ponder "why did these things happen"?

A structured way to make sure your team doesn't miss asking that question is to hold a retrospective.

What is a retrospective?

A retrospective (or "retro") is a recurring meeting used by teams to look back at the last sprint, week, or any major event in order to figure out what went well and what went poorly.

The realm of topics is wide ranging: from mishandled social interactions to achieving a major milestone. These meetings are not intended to make you feel good or bad about yourselves, they're designed to create actionable items for your team.

Setting aside dedicated time for these matters assures that they will get some attention and helps keep these conversations from spilling into normal work time.

Along with learning from your successes and failures, one of the goals of a retrospective to build trust among your team. Teams perform better when they operate in an environment of psychological safety.

How to conduct a retrospective

Anyone can host a retrospective, but hosting a good retrospective takes finesse. There are five key aspects that are paramount to a good retrospective: Facilitation, Conversational Turn Taking, Format/Activity, Action Items, and Trust.

Facilitation

Someone should volunteer to facilitate the meeting and lead the chosen activity. Depending on the activity, this can include taking notes, keeping a conversation timer, or tracking whose turn it is to speak.

A facilitator isolates the responsibility of running the meeting to one person and allows everyone else to concentrate on participating.

Conversational Turn Taking

It's important that everyone is heard. Your team should decide on a signal that makes it clear when you have something to say. My team has opted to use a finger raise to signal when you want to say something. Once someone is done speaking, motion to the next person in line to speak.

When someone has a tangential point to contribute, they can delay their turn to speak to allow the current thread of discussion to finish.

The primary motivation for the technique to is avoid interruptions and talking over each other.

Format/Activity

Free form conversation is not conducive to reaching conclusions, so pick a meeting format that fits well with your team. At the beginning of the meeting, the facilitator will explain the format and confirm that everyone is okay with that decision. Different formats optimize for different aspects of your team: project performance, interpersonal communication, or general frustration.

Picking a format gives the meeting structure and an objective, allowing the team to work together towards a known and shared goal.

Action Items

A necessary output of the meeting is a list of action items. An action item is a task that requires further action in order to accomplish it and is assigned to a specific person. You've probably experienced the situation where everyone agrees something should get done, but no one ever does it.

Sometimes you run into an action item that isn't a specific task, but possibly a general change in behavior that is meant to be addressed by the whole team. In this case, the action item would be shepherding the adoption of this new behavior for a couple weeks.

Leaving the meeting with a list of action items ensures that the tasks you spent an hour discussing actually get done.

Trust

Building trust will take time, but it is the keystone to having productive retrospectives and becoming a great team.

People thrive when working in an environment where everyone has mutual respect and the freedom to speak their mind and take risks. Google conducted a study, Project Aristotle, on hundreds of teams and determined that Psychological Safety is the most important dynamic of a successful team.

The leader of the study, Julia Rozovksy, said:

Individuals on teams with higher psychological safety are less likely to leave Google, they’re more likely to harness the power of diverse ideas from their teammates, they bring in more revenue, and they’re rated as effective twice as often by executives.

Case Study

For the last year, my team has had a weekly retro, alternating the format each time. We operate in two week sprints, so in the middle of the sprint we concentrate on interpersonal issues or other general frustrations and at the end of the sprint we focus on project-specific issues.

Mid-Sprint Retrospective

During the Mid-Sprint Retrospective, we engage in the Lean Coffee activity. The chosen facilitator will explain the activity and pass out the required supplies.

The basics of the Lean Coffee activity are:

Generate discussion topics
- Limit to 5 minutes
Vote on topics
Discuss topics
- Limit to 5 minutes, then vote on continuing with a 2 minute extension, or else move on to next topic
- Facilitator will take notes and track action items

Any topics that aren't discussed are carried over to the next meeting if anyone still has interest.

Sprint Retrospective

During the Sprint Retrospective we use a variant of the Four Quadrant activity. As with the Mid-Sprint retro, the chosen facilitator will explain the activity and pass out the required supplies.

The basics of our version of the Four Quadrant activity are:

Enumerate events that happened during the last two weeks on sticky notes.
- Limit to 5 minutes
The facilitator will draw a horizontal axis on the whiteboard, with the left side indicating bad and the right side good.
Each person will give a brief description of their stickies and place them on the axis where they think they belong.
The facilitator then draws a vertical axis, with the top indicating the event was in the team's control and the bottom that it was not in the team's control.
The facilitator quickly pulls each sticky to the appropriate place on the vertical axis. This is usually obvious, but the rest of the team will signal where they think it should go in case of disagreement.

At this point, the board should resemble something like this:

Starting in the top right corner and moving counter-clockwise, the team discusses the events in an attempt to learn. If your team is prone to drawing out discussions, consider using a timer.

Keep doing - good and in your control: give yourselves a quick pat on the back to celebrate good work.

Improve - bad and in your control: these are events that your team has the power to avoid in the future. The facilitator will lead discussion on the topics, driving toward specific action items.

Escalate - bad and out of your control: these events can only be addressed by someone external to your team. Now is the time to figure out with who to escalate the issue, or assign someone the action of figuring that out later.

Kudos - good and out of your control: these are positive events that were caused by someone external to your team. Here the team will assign an action to someone to reach out and express the team's gratitude.

Conclusion

Done right, retrospectives can be a boon for successful and struggling teams alike.

The goal is to build a culture of trust among your team, where everyone feels safe to express themselves without the fear of being punished for making a mistake or speaking their mind. If there are barriers to bringing up problems on your team, you can never expect to be able to work through them and improve.

If your team has never participated in a retrospective, my challenge to you is to bring the idea to your team and get it on the calendar!

Reducers: Exploring State Management in React (Part 2)

Tue, 23 Oct 2018 23:00:00 -04

From Mitchell Hanberg's Blog: In a previous [post](https://www.mitchellhanberg.com/post/2018/07/25/exploring-state-management-in-react-container-components/), we demonstrated how the Container/Presenter pattern is a solid approach to managing your React state. This time we are going to look into using Reducer functions as the method to managing change in state of your components. ## Reduce Reduce (also known as a [fold](https://en.wikipedia.org/wiki/Fold_%28higher-order_function%29)) is a functional programming concept that deals with the transformation of data structures using recursion and higher order functions. If you have used either the `Array.prototype.reduce` or `Array.prototype.map` [functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), you already have experience with this technique. ## The Approach The general approach is to have a `reduce` (can be named whatever you'd like) function that understands how to respond to certain messages and will output the transformed state. We'll normally call this `reduce` function from a `dispatch` function. This is essentially the same pattern you use with [Redux](https://redux.js.org), but we don't need to install any packages to use it. Let's examine the code snippet below. ```jsx function reduce(prevState, message) { switch (message.type) { case "ADD": return { items: [...prevState.items, prevState.newItem], newItem: "" }; case "REMOVE": return { items: prevState.items.filter( (i, idx, prevItems) => idx !== prevItems.indexOf(message.item) ) }; case "CHANGE": return { newItem: message.item }; case "DISCOUNTS": return { discounts: message.discounts }; case "INITIAL": return { newItem: "", items: [], discounts: [] }; default: throw new Error("Unknown message type received"); } } class Cart extends React.Component { state = reduce(undefined, { type: "INITIAL" }); componentDidUpdate(prevProps, prevState) { if (prevState.items.length !== this.state.items.length) { const itemsQuery = this.state.items.join(","); ajax(`https://discountdb.com/?items=${itemsQuery}`) .then(discounts => this.dispatch({ type: "DISCOUNTS", discounts })); } } dispatch = action => this.setState(prevState => reduce(prevState, action)); onNewItemChange = event => this.dispatch({ type: "CHANGE", item: event.target.value }); addItem = () => this.dispatch({ type: "ADD" }); removeItem = item => () => this.dispatch({ type: "REMOVE", item }); render() { return (

Cart

{item}, {this.state.discounts[idx]}% off!

); } } ``` [![Edit zrww3wp57m](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/zrww3wp57m) Here our `reduce` function resolves to a switch statement which delegates according to certain messages. We call this function in two places: directly in our `state` initializer to bootstrap our component and in our `dispatch` function to allow our event handlers to dynamically pass messages. Unlike the function you pass to `Array.prototype.reduce`, our reduce only returns the changes to state and not the entire new state. This is because we only pass changes to `this.setState`. _Notice that the only place we call `this.setState` directly is in the `dispatch` function._ ## Benefits What we have done is extract and enumerate the various transformations that can happen to our component state. Isolating our state transformations this way can be beneficial when it comes to unit testing; our reducer is just plain JavaScript (no React). We fully extracted all state transformations into the reducer, but you are free to only pull out the ones that can benefit from the indirection. I have added this technique to a React codebase that was written with no state management patterns in mind, and I found that it really simplified and focused each component. By creating the `dispatch` function, we are able to pass only one function as a prop to child components if they need to manipulate their parent's state. I found that this drastically reduces [prop drilling](https://blog.kentcdodds.com/prop-drilling-bb62e02cb691). ## Drawbacks While this allows you to pass fewer callbacks to your child components, you will still need to thread it through your component tree if you want to modify top-level state from a leaf-node. If you're implementing this pattern and think to yourself (like how I felt writing the above contrived example), "Why am I even doing this?" your component(s) might not be complex enough to warrant this. ## Wrapping Up This isn't an original concept; [Dan Abramov](https://twitter.com/dan_abramov) has discussed this before and his [article](https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367) is also worth reading. This post is mostly an exercise in exploring different ways to organize and transform React component state. Next time you are working with a React component, try to think of new ways you can work with state and let me know what you come up with on Twitter: [@mitchhanberg](https://twitter.com/mitchhanberg).

How to use Elixir LS with Vim

Thu, 18 Oct 2018 08:00:00 -04

From Mitchell Hanberg's Blog: ### What is Elixir LS? [Elixir LS](https://github.com/elixir-lsp/elixir-ls) by Jake Becker (now maintained by the [elixir-lsp](https://github.com/elixir-lsp) organization) is the language server implementation for Elixir. ### What is a language server? If you've been following the story of [Visual Studio Code](https://code.visualstudio.com), there is a chance you've heard of another recent creation from Microsoft: the [Language Server Protocol](https://langserver.org). >The Language Server Protocol (LSP) defines the protocol used between an editor or IDE and a language server that provides language features like auto complete, go to definition, find all references etc. This allows creators to build universal "language servers" that can be used by any text editor. ### How to integrate with Vim Using a language server requires a client implementation for your editor and we are going to use [ALE](https://github.com/dense-analysis/ale) by dense-analysis. If you're using [vim-plug](https://github.com/junegunn/vim-plug) you can install ALE by adding the following to your `.vimrc` and running `:PlugInstall`. Otherwise, consult your plugin manager's documentation. ```vim " .vimrc call plug#begin('~/.vim/bundle') ... Plug 'dense-analysis/ale' call plug#end() ``` Now let's install Elixir LS! ```shell $ git clone git@github.com:elixir-lsp/elixir-ls.git $ cd elixir-ls && mkdir rel # checkout the latest release $ git checkout tags/v0.4.0 $ mix deps.get && mix compile $ mix elixir_ls.release -o rel ``` Perfect, our final step is to configure ALE to use Elixir LS. ```vim " .vimrc " Required, explicitly enable Elixir LS let g:ale_linters.elixir = ['elixir-ls'] " Required, tell ALE where to find Elixir LS let g:ale_elixir_elixir_ls_release = expand("") " Optional, you can disable Dialyzer with this setting let g:ale_elixir_elixir_ls_config = {'elixirLS': {'dialyzerEnabled': v:false}} " Optional, configure as-you-type completions set completeopt=menu,menuone,preview,noselect,noinsert let g:ale_completion_enabled = 1 ``` ### Now what? I would familiarize yourself with the [features of ALE](https://github.com/dense-analysis/ale#usage) and decide how you want to incorporate them into your workflow. ALE doesn't prescribe any keymappings, so feel free to experiment to see what works best for you! Check out my [.vimrc](https://github.com/mhanberg/.dotfiles/blob/fb9831367e5543aa84df15b0d1b08e8993c6a905/vimrc#L203..L232) to see how I use ALE.

Announcing PlanetEx: an open source blog aggregator written in Elixir

Mon, 01 Oct 2018 13:00:00 -04

From Mitchell Hanberg's Blog:

Elixir in Action: Book Review

Wed, 19 Sep 2018 09:00:00 -04

From Mitchell Hanberg's Blog: ### Who is the target audience? The book is intended for beginner and intermediate Elixir developers. As the book progresses, the author dives into topics that get more complex, which might not be suitable unless you already understand the basics of Elixir. ### Review _Elixir in Action_ covers the full breadth of all that is Elixir, from the basic syntax to building distributed, fault tolerant, and scalable systems. This is definitely a lot, especially if _Elixir in Action_ is the first book on Elixir you've read. The book is broken into three parts: The Language, The Platform, and Production. If this is your first foray into Elixir, I would suggest reading The Language and then putting the book down and write some code. You're going to be able to understand and absorb so much more from part 2 (The Platform) once you become comfortable with the syntax and the functional paradigm. The author provides numerous exercises to extend the examples he provides throughout the book. The Platform dives into what really makes Elixir shine, which is the BEAM and the concurrency model that enables you to develop scalable and fault tolerant software. I would highly suggest working through the examples (or start a side project!) while reading this part. Reading concurrent code can be tough, so being able to see it _in action_ will accelerate your understanding of how to develop software in Elixir. Production covers the basics of how software in the Erlang ecosystem is generally packaged and deployed. This is possibly more involved than other languages you've worked in because Elixir allows you to do _hot code upgrades_ without restarting the system. I read _Elixir in Action_ about a year into my Elixir journey and I definitely wished I would have read it in the beginning, but I still learned a lot and would recommend it to anyone interested in Elixir.

Writing an Absinthe Phase

Fri, 07 Sep 2018 22:35:36 +0200

From Maarten van Vliet: Absinthe does a lot when you fire a GraphQL query at it. The incoming query is parsed into an internal representation, validated and finally executed. This process is done by phases, these are individual modules chained together in a pipeline that each do a single step in processing the queries. Phases in Absinthe do a lot of work. They are the building blocks in validating and executing the GraphQL query. E.

Absinthe Tips and Tricks

Wed, 05 Sep 2018 22:18:38 +0200

From Maarten van Vliet: Absinthe is a great package for building GraphQL api’s in Elixir. It is fast, good DSL and overall great implementation of the GraphQL spec for servers. Working with Absinthe I’ve come across some patterns that have helped clean up code. I’d like to share some of them here. The Self function Imagine you have an image object you want to expose, and for each image you want a separate object with just the dimensions of the image.

How to Subscribe to SharePoint RSS Feeds Without NTLM Authentication

Sat, 18 Aug 2018 21:00:00 -04

From Mitchell Hanberg's Blog:

Metaprogramming Elixir: Book Review

Sat, 18 Aug 2018 09:00:00 -04

From Mitchell Hanberg's Blog: ### Who is the target audience? Advanced beginner to intermediate Elixir developers who have mastered the syntax and basic structure of Elixir applications who want to add advanced language features to their skill set. ### Review Chris McCord (creator of the [Phoenix Framework](https://phoenixframework.org/)) introduces you to the power of macros with the Elixir programming language. This book (a member of the [Pragmatic exPress](https://pragprog.com/pragmatic-express) series) is short and to the point. If you're reading this book, you probably are interested in the practical application of macros and metaprogramming, and this book delivers. _Metaprogramming Elixir_ guides you through the basics of defining macros, but quickly dives into best practices and how you can use these techniques to improve your real life code. In addition to showing you when it's most appropriate to utilize a macro, Chris teaches you how to test macros and what aspects of metaprogramming are worth testing. As a practitioner of [Test Driven Development](https://en.wikipedia.org/wiki/Test-driven_development), I find this incredibly valuable. I thoroughly enjoyed this book and will definitely be referencing it in the future.

Swotex hex package

Sun, 12 Aug 2018 23:04:18 +0200

From Maarten van Vliet: Swotex hex package Identify email addresses or domains names that belong to colleges or universities.

Container Components: Exploring State Management in React (Part I)

Wed, 25 Jul 2018 00:00:00 -04

From Mitchell Hanberg's Blog: >At what level of complexity will my React application require Redux? React developers have been asking this question for a long time, and answers still vary wildly. The truth is there is quite a bit we can do before needing to pull in Redux, and even then, _**Redux**_ isn't our only option! Even the creator of Redux, [Dan Abramov](https://twitter.com/dan_abramov?lang=en) thinks that we might not need Redux (although, I think the spirit this statement applies to all 3rd-party libraries meant to help reduce complexity of state).

You Might Not Need Redux https://t.co/3zBPrbhFeL
— Dan Abramov (@dan_abramov) September 19, 2016

In this series, we'll explore a few different patterns you can introduce to your code base before reaching for a 3rd party solution! ## Container/Presenter Components This pattern separates what might be a single component into two: a Container component to maintain state and a Presenter component to render visual markup. ```jsx const Cart = props => (

Cart

{item}, {props.discounts[idx]}% off!

); class CartContainer extends React.Component { state = { newItem: "", items: [], discounts: [] }; componentDidUpdate(prevProps, prevState) { if (prevState.items.length !== this.state.items.length) { const itemsQuery = this.state.items.join(","); ajax(`https://discountdb.com/?items=${itemsQuery}`) .then(discounts => this.setState({ discounts })); } } onNewItemChange = event => this.setState({ newItem: event.target.value }); addItem = () => { this.setState(prevState => ({ items: [...prevState.items, prevState.newItem], newItem: "" })); }; removeItem = item => () => { this.setState(prevState => ({ items: prevState.items.filter( (i, idx, prevItems) => idx !== prevItems.indexOf(item) ) })); }; render() { return (

); } } ``` [![Edit wo7y9voowk](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/wo7y9voowk) Here we can see that we have a Container component, `CartContainer`, that handles controlling component state with the `addItem`, `removeItem`, and `onNewItemChange` callbacks, and fetching a list of discounts from an external REST api. This enables us to write `Cart`, our Presenter component, as a Pure Functional component. After extracting a Container and a Presenter from one of our bigger components, we might find the Container to still be fairly large, or handling several concerns, potentially signaling that we can break down our Container even further. In our case, we might extract a `DiscountContainer` from `CartContainer` to segregate the logic of maintaining the contents of the cart from the logic of fetching the discounts for those items. The hierarchy of this would look like `CartContainer` -> `DiscountContainer` -> `Cart`, having `CartContainer` pass the discount-less items to the `DiscountContainer`, which will fetch the discounts and then pass the now discounted items to the `Cart`. ## Benefits Partitioning our components on their state boundary will help reduce complexity by simply having less code to work with at a time, while still staying "inside React". I think this pattern really starts to pay dividends when we have a lifecycle method, like `componentDidUpdate`, doing a lot of asynchronous work (like making HTTP requests). Given the asynchronous nature, this sort of code tends to be very difficult to test (with both automated unit testing and manual testing), so breaking this stateful logic into separate components helps keeps us sane and our code focused. It's helpful to remind ourselves that when unit testing a React component, we are essentially testing the `render` function. Given the inputs (`props`), what is the output? You've probably noticed tests are painful to write if there is a lot of setup, especially if the setup is required for a feature of the component that you aren't even testing. Keeping our components small and focused will go a long way for keeping ourselves happy and productive! ## Drawbacks While the Container/Presenter pattern is not always one-for-one (`Cart` <-> `CartContainer`), you will encounter a lot of similarly named components. This can sometimes cause a communication breakdown amongst the team, as you will trip over your own words attempting to say things like "The CartContainer passes the products to the Cart which then passes them to the Checkout component, or is it the CheckoutContainer component?". If you can think of better names, I would suggest using them! Your code will still be following the pattern even if they don't have the word Container in the name. 😏 ## Wrapping Up My team has utilized this pattern heavily, and I believe it is a solid option to consider before reaching for a tool like Redux. If you've never heard of this pattern and would like to learn more, Dan Abramov [has also written about this topic](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0). Now try this in your codebase or introduce the idea to your team during a lunch-and-learn and let me know how it goes!

Building with Elm at SEP:Makes

Thu, 08 Mar 2018 09:00:00 EST

From Mitchell Hanberg's Blog:

Integrate and Deploy React with Phoenix

Thu, 22 Feb 2018 08:00:00 EST

From Mitchell Hanberg's Blog:

You've just finished your lightning fast Phoenix JSON API, what's next?

Motivation

My most recent side project, Contact, is a JSON REST API written with Elixir and Phoenix, designed to be the backend to an instant messaging application (e.g., Slack). There was a hackathon coming up at work, and I thought it'd be fun to make a frontend for Contact during it, and although Contact's development was thoroughly test-driven, I wanted to make sure that my API was ready to be used.

The hackathon was two weeks away, so I needed to quickly prototype a UI to flesh out any oversights I made.

I decided to go with React over basic server-rendered html templates because my next project at work will be using React and figured I could use this to level up my skills.

Let's add React!

If you generated your Phoenix project using the mix phx.new --no-html --no-brunch command, you're good to go!

If not, let's rip out the stock html and Javascript scaffolding that Phoenix generates for you. You can safely remove the priv/assets directory (which contains all of the Brunch configuration) and lib/<path to your web directory>/templates, along with any Phoenix views, controllers, and routes that you aren't using.

A good place to install our React app is the priv directory, so let's move into there and run the installer.

# priv/
$ npx create-react-app contact-react 
$ cd contact-react 
$ yarn start # npm start if you don't use yarn

create-react-app gets us set up with React, Babel, and Webpack out of the box, allowing us to get started developing our application and not mess around with a ton of esoteric configuration.

Success!

We now have a development server running, serving the generated React application.

Connecting the frontend to the backend

You may have noticed that your Phoenix server and the React development server are running on two different ports, how can we allow our two applications to communicate with each other?

Development

We'll set up a proxy for development, so we won't have to specify the absolute URI of the API endpoints we want to hit. Let's add this line to our package.json.

"proxy": "http://localhost:4000"

This line will set all network request URIs to be made relative to our Phoenix server.

Production

In production, we'll have the Phoenix server send the frontend to the client.

To accomplish this, we'll set up the root endpoint to serve the contents of the build directory of our React app.

# endpoint.ex

plug(Plug.Static.IndexHtml, at: "/")
plug(
  Plug.Static,
  at: "/",
  from: "priv/contact-react/build/",
  only: ~w(index.html favicon.ico static service-worker.js)
)

Plug.Static.IndexHtml will allow us to serve the index.html that Webpack generates from the root endpoint.

Now if we run yarn build, start our Phoenix server, and navigate to localhost:4000 in the browser, we should see our React application!

Deployment

Since we have added another build step to our workflow, we'll need to include that in our deployment process. I will describe the steps needed to deploy using Travis CI.

I added a before_deploy step and set the skip_cleanup flag to the deploy step to my .travis.yml file, resembling the following.

before_deploy:
  - rm -rf ~/.nvm && curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash && nvm install node && nvm use node
  - cd priv/contact-react && yarn install && yarn build && cd - 
deploy:
  skip_cleanup: true

A breakdown of what is happening here:

Reinstall the latest version of Node Version Manager.
Install the latest version of Node.js.
Set the current version of Node.js to the one we just installed.
Build our React application (Yarn is already installed).
Tell Travis to deploy the compiled React application (otherwise, Travis would see the build directory as a build artifact and clean it up before deployment).

It's time to get to work!

In 10 minutes we've gone from nothing to a deployed application!

Following these steps allowed me to get right to business; I was successful in prototyping 90% of my application before the hackathon.

References

Version Your Dotfiles for Great Good

Mon, 29 Jan 2018 09:00:00 EST

From Mitchell Hanberg's Blog:

What are dotfiles?

Your dotfiles are the hidden files or folders that live in your home directory, for example your .vimrc and your .bashrc.

What do I mean by version?

By "version", I mean to track your dotfiles using a version control system, like git, and a hosting service, like Github.

Why would you want to version them?

Versioning your dotfiles allows you to track them and to be able to share them between computers, making it easy to provision a new computer.

Let's get started

There's a good chance that you arleady have some dotfiles, don't worry, it's easy to start tracking them. Our first order of business is to install a handy suite of tools called rcm, which abstracts the process of symlinking our dotfiles.

On macOS we would install via Homebrew.

$ brew install rcm

rcm expects a ~/.dotfiles directory, so let's create that and initialize our git repository.

$ mkdir ~/.dotfiles && cd ~/.dotfiles && git init

At this point, if you have any dotfiles (you probably do), you'll want to add them to your ~/.dotfiles directory, and for this, we use the mkrc tool provided by rcm.

$ mkrc .vimrc
$ mkrc .zshrc
$ mkrc .rubocop.yml

At this point, rcm has copied these files to your ~/.dotfiles directory with the dot stripped from the name (.vimrc -> vimrc) and replaced the copy in your home directory with a symlink to the new file in your ~/.dotfiles directory.

What about my vim plugins?

For most vim plugin managers, you are probably going to be cloning at least one git repository somewhere in your ~/.vim directory. If you don't plan on ever updating these repos, you can go ahead and run mkrc .vim.

If you want to be able to update these plugins (or any other tool you use which relies on a git repo), you'll need to use git submodules. I attempted to turn my existing vim plugins into submodules within my .dotfiles repository, but I wasn't successful. So instead of re-cloning each plugin as a submodule, I decided to switch to a vim plugin manager that doesn't require manually cloning repos.

I opted to start using vim-plug over pathogen, which requires less boilerplate and all of the configuration goes in your .vimrc.

Once I was done, the section of my .vimrc handling my vim plugins looked like so:

" Install vim-plug and plugins if vim-plug is not already installed
if empty(glob('~/.vim/autoload/plug.vim'))
  silent !curl -fLo ~/.vim/autoload/plug.vim --create-dirs
    \ https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
  autocmd VimEnter * PlugInstall --sync | source $MYVIMRC
endif

" Plugins
call plug#begin('~/.vim/bundle')
Plug 'slashmili/alchemist.vim'
Plug 'kien/ctrlp.vim'
Plug 'vim-airline/vim-airline'
Plug 'tpope/vim-bundler'
Plug 'tpope/vim-dispatch'
Plug 'elixir-editors/vim-elixir'
Plug 'tpope/vim-endwise'
Plug 'tpope/vim-fugitive'
Plug 'airblade/vim-gitgutter'
Plug 'JamshedVesuna/vim-markdown-preview'
Plug 'tpope/vim-rails'
Plug 'tpope/vim-sensible'
Plug 'janko-m/vim-test'
Plug 'christoomey/vim-tmux-navigator'
call plug#end()

Yeah, but what about the submodules I can't avoid making?

Thought you might ask that, I encountered the same challenge. I use oh-my-zsh for zsh customizations (mostly the themes¯\_(ツ)_/¯), which relies on a git repository in your home directory .oh-my-zsh.

While I wasn't able to transfer the existing directory to my new .dotfiles directory, I was able to reclone it as a git submodule.

$ cd ~/.dotfiles
$ git submodule add -b master <repo url>
$ git submodule init # you should only have to run this the first time
$ rcup -v

The submodule is set up to track the master branch, has been cloned into your repository, and a symlink to your home directory has been made using the rcup tool provided by rcm.

If you wish to update it at any time, you only need to move into the directory of the submodule and do a git pull, followed by returning to the parent repository and committing the change.

Final Steps

Now that you have all of your dotfiles in a git repository, it's time to push that repository to Github and figure out how you are going to install these dotfiles the next time you are setting up a computer.

Provisioning a new machine with your dotfiles

This is the part we've been working towards, and thanks to our efforts, this part is a breeze.

# Install git if not installed
# Install rcm

$ git clone --recursive <url> ~/.dotfiles
$ rcup -v

Voila!

If you want to make it even easier to install, rcm provides a utlity to generate a standalone install script.

The rcup(1) tool can be used to generate a portable shell script. Instead of running a command such as ln(1) or rm(1), it will print the command to stdout. This is controlled with the -g flag. Note that this will generate a script to create an exact replica of the synchronization, including tags, host-specific files, and dotfiles directories.

env RCRC=/dev/null rcup -B 0 -g > install.sh

Using the above command, you can now run install.sh to install (or re-install) your rc files. The install.sh script can be stored in your dotfiles directory, copied between computers, and so on.

Wrapping Up

If you've followed along and have made it this far, congratulations! You now have a backup of all of your configuration files!

If you started reading this, but thought, "Dang, I don't have any dotfiles to version, why am I reading this?", you're in luck! Since versioning one's dotfiles is a common practice, there are plenty of repositories out there for which you can choose to fork and start your own collection.

For example, if you were to checkout my dotfiles you would find a pretty basic setup for ruby and elixir development, along with helpful configurations for tmux and vim, which would be a good starting point if you didn't want to curate your dotfiles from scratch.

Looking back at year in tech

Sat, 30 Dec 2017 22:34:06 +0200

From Maarten van Vliet: Retrospective Last year was an interesting year for me. I was able to try out a whole lot of new technologies, assess their capabilities and get a good look at their pros and cons. I want to go over a couple of them, and shortly summarize my findings. Typescript In short, Typescript made Javascript fun for me again. Although a lot of this can be attributed to the support of ES6/ES7 in Typescript.

Upgrading Phoenix to Http2

Fri, 15 Dec 2017 21:30:43 +0100

From Maarten van Vliet: Upgrading phoenix framework to serve http2 Http2 is the next version of the http protocol and offers several advantages. It serves over a single connection, reducing the number of roundtrips necessary. With multiplexing it can handle multiple requests at the same time and as a whole is just better. As the internet slowly moves to support http2, Phoenix does not lag behind. The webserver Phoenix uses, Cowboy, has released version 2 with support for http2 and the updates to Phoenix and Plug have followed in its path.

Implementing API Authentication with Guardian in Phoenix

Tue, 28 Nov 2017 09:00:00 EST

From Mitchell Hanberg's Blog:

Most applications need some sort of authentication and authorization, and REST API's are no different. If you are familiar with web development but have never worked on one that does not have a front end (like me), then the authentication functionality might stump you at first.

What is Guardian?

Guardian is a token based authentication library for use with Elixir applications.

More can be learned by reading its documentation, which I highly recommend.
Keep in mind that the "tokens" that Guardians refers to are JSON Web Tokens.

Installation and Configuration

Add Guardian 1.0 as a dependency in mix.exs.

{:guardian, "~> 1.0"}

And install

$ mix deps.get

Guardian requires that you add an implementation module, I added mine to an auth folder in my web directory.

# lib/my_app_web/auth/guardian.ex

defmodule MyAppWeb.Guardian do
  use Guardian, otp_app: :my_app

  def subject_for_token(resource, _claims) do
    # You can use any value for the subject of your token but
    # it should be useful in retrieving the resource later, see
    # how it being used on `resource_from_claims/1` function.
    # A unique `id` is a good subject, a non-unique email address
    # is a poor subject.

    sub = to_string(resource.id)
    {:ok, sub}
  end

  def resource_from_claims(claims) do
    # Here we'll look up our resource from the claims, the subject can be
    # found in the `"sub"` key. In `above subject_for_token/2` we returned
    # the resource id so here we'll rely on that to look it up.

    id = claims["sub"]
    resource = MyApp.get_resource_by_id(id)
    {:ok,  resource}
  end
end

There are two functions that you are required to implement, subject_for_token/2 and resource_for_claims/2. The compiler will complain if they are not implemented.

The resource refers to a user, and the sub (subject) is the user's primary key (or another unique identifier). The function MyApp.get_resource_by_id(id), that is called in resource_from_claims/2, is just a placeholder. You will need to implement that function (the name is not important, it can be whatever you want) and it should retrieve the user based on the sub (subject).

This is taken directly from Guardian's example code.
More can be learned about claims by reading the JSON Web Token documentation

Finally, we add a config to config.exs

config :my_app, MyAppWeb.Guardian,
       issuer: "my_app",
       secret_key: "Secret key. You can use `mix guardian.gen.secret` to get one"

You will need to create a secret key using the method above. If you're writing a production application, you should use an environment variable.

The atom :my_app corresponds to the atom in the implementation module and the namespacing of the module also corresponds to the implementation module.
The value for the key issuer can be whatever you want.

Authentication

Our next step will be to perform the authentication of the credentials that the client has sent to our API.

def authenticate(%{user: user, password: password}) do
  # Does password match the one stored in the database?
  case Comeonin.Bcrypt.checkpw(password, user.password_digest) do
    true ->
      # Yes, create and return the token
      MyAppWebWeb.Guardian.encode_and_sign(user)
    _ ->
      # No, return an error
      {:error, :unauthorized}
  end
end

This is my authentication function, it takes the User struct that I located in the database based on the unique identifier that was passed by the request (in my case can be either an email address or a username) and the password attempt.

I am using the password hashing library Comeonin to hash my passwords, so here I use the checkpw/2 function to check the password attempt against the digest (AKA a hash) stored in the database. This function returns either true or false, so if the password is correct, we fall into the true case and we create our token (JSON Web Token, or JWT) and return it.

Otherwise we return the tuple {:error, :unauthorized} to signify that the authentication attempt failed.

The Controller

Let's expose this functionality to our public API by making a controller endpoint to sign in a user.

def sign_in(conn, params) do
  # Find the user in the database based on the credentials sent with the request
  with %User{} = user <- Accounts.find(params.email) do
    # Attempt to authenticate the user
    with {:ok, token, _claims} <- Accounts.authenticate(%{user: user, password: login_cred.password}) do
      # Render the token
      render conn, "token.json", token: token
    end
  end
end

Here we find the user in the database and authenticate the user. If the authentication is successful, we render the token back to the consumer.

Note: Here I am using the with syntax along with Phoenix's action_fallback functionality.

Authorization

In the context of a web application, this is the process of fencing off most of the routes from unauthenticated visitors. However, there are two routes that should not be fenced off, the route to sign in a user and the route to create a user.

# router.ex

pipeline :api do
  plug :accepts, ["json"]
end

pipeline :api_auth do
  plug MyAppWeb.Guardian.AuthPipeline
end

scope "/api", MyAppWeb.Api do
  pipe_through :api

  resources "/users", UserController, only: [:create]
  post "/users/sign_in", UserController, :sign_in
end

scope "/api", MyAppWeb.Api do
  pipe_through [:api, :api_auth]

  resources "/users", UserController, only: [:update, :show, :delete]
end

For those unfamiliar with pipelines, please reference the Phoenix guides.

We define a new pipeline called api_auth for routes that require authorization, which in my case will be all routes except for UserController#sign_in and UserController#create.

Phoenix lets us define the same scopes multiple times without overwriting them. Here I define the api and v1 scopes twice, piping the first only through the api pipeline and piping the second through the api and api_auth pipelines.

The api_auth pipeline consists of a custom plug I defined in /lib/my_app_web/auth/auth_pipeline.ex.

# /lib/my_app_web/auth/auth_pipeline.ex

defmodule MyAppWeb.Guardian.AuthPipeline do
  use Guardian.Plug.Pipeline, otp_app: :my_app,
                              module: MyAppWeb.Guardian,
                              error_handler: MyAppWeb.Guardian.AuthErrorHandler

  plug Guardian.Plug.VerifyHeader
  plug Guardian.Plug.EnsureAuthenticated
end

The first line of this plug defines some boiler plate that Guardian will use. The last two lines are what we want to check the authorization of the user. VerifyHeader will look for the the Authorization header in the request, which should contain Bearer <your token>, and EnsureAuthenticated will make sure that the token is valid.

In the first line of boiler plate, we defined an error handler, MyAppWeb.Guardian.AuthErrorHandler, mine consists of the example code from the Guardian documentation.

# /lib/my_app_web/auth/auth_error_handler.ex

defmodule MyAppWeb.Guardian.AuthErrorHandler do
  import Plug.Conn

  def auth_error(conn, {type, _reason}, _opts) do
    body = Poison.encode!(%{message: to_string(type)})
    send_resp(conn, 401, body)
  end
end

Testing

At first I was unsure of how to test this functionality, but the solution turned out to be rather simple.

I've organized my test file to have two describe blocks, one for tests that require authentication and one for tests that don't require it. I have a top level setup block that adds the headers to the request that are common to all tests.

In the describe block for the tests requiring authentication, I wrote another setup block.

setup %{conn: conn} do
  # create a user
  user = insert(:user, email: "user@email.com", username: "user")

  # create the token
  {:ok, token, _claims} = MyAppWeb.Guardian.encode_and_sign(user)

  # add authorization header to request
  conn = conn |> put_req_header("authorization", "Bearer #{token}")

  # pass the connection and the user to the test
  {:ok, conn: conn, user: user}
end

Any requests you make in your tests should now have the appropriate headers!

I am using the ExUnit testing framework (comes with Elixir).

If you found this helpful, please let me know! You can find me on twitter as @mitchhanberg or you can shoot me an email.

How to install Pharo on Gnu/Linux

Fri, 24 Nov 2017 00:14:59 GMT

From ⚡ Maqbool Khan: Pharo the Modern Smalltalk Download the Pharo and decompress the file $ unzip Pharo.zip $ sudo mv Pharo /opt/ Create the pharo.desktop file and paste the following contents [Desktop Entry] Encoding=UTF-8 Name=Pharo GenericName=Pharo Exec=pharo Icon=...

Scheduling Cron Jobs on Heroku with Ruby on Rails

Wed, 25 Oct 2017 09:00:00 -04

From Mitchell Hanberg's Blog: A common practice is to create a __cron job__ whenever you have a task you need done periodically. >The software utility Cron is a time-based job scheduler in Unix-like computer operating systems. People who set up and maintain software environments use cron to schedule jobs (commands or shell scripts) to run periodically at fixed times, dates, or intervals. [[1]](#1) On something like AWS, you would have the ability to create normal cron jobs and, when dealing with a Ruby on Rails application, you could use the Whenever gem [[2]](#2) to interface between Cron and your application code.

On Heroku, this isn't possible.

This is due to Heroku's Dyno [[3]](#3) infrastructure, which is composed of virtualized Linux containers that are restarted daily, which resets it's file system. Heroku also states that Cron does not perform well on horizontally scaling platforms [[4]](#4). Luckily, Heroku has an add-on that just came out of beta which makes for a pretty easy solution. The Scheduler [[5]](#5) add-on is free, utlizes one-off dynos (whose uptime will count towards your monthly usage), and will make use of Rake tasks (for non-rails applications, scripts can be add to the `bin/` directory). Let's install the add-on. This can be done via the CLI or the web UI, but I'll show you the CLI method. (This assumes you already have the Heroku CLI installed and logged in). ```zsh $ heroku addons:create scheduler:standard ``` Now let's define a task. Let's say you're app needs to send a reminder for customers with appointments that day. ```ruby desc "Send appointment reminders" task :send_reminders => :environment do # :environment will load our Rails app, so we can query the database with ActiveRecord appts = Appointments.where(appointment_date: Date.today) appts.each do |appt| AppointmentMailer.reminder(appt) end end ``` Now it's time to deploy this code. Great, now how do we schedule this task to run? Let's hop over to Heroku's web UI. You can find this in the list of installed add-ons on the dashboard for your app, or you can run the following command in your terminal. (If you have more than one app, append `--app ` to the command.) ```shell $ heroku addons:open scheduler ``` You should now see a screen similar to this. ![](/images/scheduler-add-on.jpg) Since we want to remind customers of their appointments for the day, we'll set the __Frequency__ to __Daily__ and the __Next Due__ to __10:00__. Note that the __Next Due__ time is in UTC, so __10:00__ is 6:00AM where I live. After clicking __Save__, your scheduled job should be live. And there we have it! This solution is ideal for basic tasks like sending emails, but for heavier, longer running jobs, you should look into configuring a Custom Clock process [[6]](#6).
[1] [https://en.wikipedia.org/wiki/Cron](https://en.wikipedia.org/wiki/Cron)
[2] [https://github.com/javan/whenever](https://github.com/javan/whenever)
[3] [[https://www.heroku.com/dynos](https://www.heroku.com/dynos)
[4] [https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/](https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/)
[5] [https://elements.heroku.com/addons/scheduler](https://elements.heroku.com/addons/scheduler)
[6] [https://devcenter.heroku.com/articles/scheduled-jobs-custom-clock-processes](https://devcenter.heroku.com/articles/scheduled-jobs-custom-clock-processes)

Encoding Ecto Validation Errors in Phoenix 1.3

Mon, 23 Oct 2017 09:00:00 -04

From Mitchell Hanberg's Blog: # Problem I recently ran into this error while implementing the first endpoint of my Phoenix JSON API. ```shell ** (Poison.EncodeError) unable to encode value: {:username, {"has already been taken", []}} ``` After a bit of googling and detective work, I found the offending piece of code, located in my `error_view.ex` file. ```elixir def render("409.json", %{changeset: changeset}) do %{ status: "failure", errors: changeset.errors # this line causes the error } end ``` This function handles rendering the JSON payload that the controller sends back to the client when there is an error. The `errors` property of the `changeset` struct is a [keyword list](https://elixir-lang.org/getting-started/keywords-and-maps.html#keyword-lists)* of `error`'s, with `error` being a type defined in the [Changeset module](https://github.com/elixir-ecto/ecto/blob/v2.2.6/lib/ecto/changeset.ex#L250). ```elixir @type error :: {String.t, Keyword.t} ``` [Poison](https://github.com/devinus/poison) is not able to encode this, so a `Poison.EncodeError` error is raised. \* It's important to remember that a keyword list is a list of 2-item tuples with the first item of the tuple being an atom. So the error we originally saw was the key-value pair that couldn't be encoded, shown in tuple form. --- # Solution If you created your Phoenix app when Phoenix was at v1.3, then you should have this function in the `/lib/your_app_web/views/error_helpers.ex` file. If not, go ahead and paste it in that file. ```elixir @doc """ Translates an error message using gettext. """ def translate_error({msg, opts}) do # Because error messages were defined within Ecto, we must # call the Gettext module passing our Gettext backend. We # also use the "errors" domain as translations are placed # in the errors.po file. # Ecto will pass the :count keyword if the error message is # meant to be pluralized. # On your own code and templates, depending on whether you # need the message to be pluralized or not, this could be # written simply as: # # dngettext "errors", "1 file", "%{count} files", count # dgettext "errors", "is invalid" # if count = opts[:count] do Gettext.dngettext(ContactWeb.Gettext, "errors", msg, msg, count, opts) else Gettext.dgettext(ContactWeb.Gettext, "errors", msg, opts) end end ``` And then we make the following change. ```diff def render("409.json", %{changeset: changeset}) do %{ status: "failure", - errors: changeset.errors # this line causes the error + errors: Ecto.Changeset.traverse_errors(changeset, &translate_error/1) } end ``` Here we use the [Ecto.Changeset.traverse_errors/2](https://hexdocs.pm/ecto/Ecto.Changeset.html#traverse_errors/2) function to apply the `translate_errors/1` function to each error, which will return a map that can then be encoded by Poison. Here is the JSON that we can now render and send to the client! ```json { "status": "failure", "errors": { "email": [ "has already been taken" ] } } ``` --- If you found this helpful, please let me know! You can find me on twitter as [@mitchhanberg](https://twitter.com/mitchhanberg) or you can shoot me an email.

Installing Erlang and Elixir with asdf

Thu, 05 Oct 2017 11:30:00 -04

From Mitchell Hanberg's Blog: **Let's set the scene** _You've been fully entrenched in the Ruby and Rails world for 10 months_ _You've just tied a bow on your latest side project_ _You're already bored and excited to start something new_ _For the sake of this post, you work on a mac_ So you've decided to mess around with Elixir! Nice choice, let's get started. --- ## What is Erlang? > Erlang is a programming language used to build massively scalable soft real-time systems with requirements on high availability. Some of its 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. ## What is Elixir? > Elixir is a 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. Since you are coming from a Ruby background, you know how valuable using a version manager like [rbenv](https://github.com/rbenv/rbenv) or [rvm](https://github.com/rvm/rvm) can be. Since we are going to be installing two different programming language platforms, let's find a solution that can handle all of our needs. ## What is asdf? > _extendable version manager_ > > Supported languages include Ruby, Node.js, Elixir and more. Supporting a new language is as simple as this plugin API. [asdf](https://github.com/asdf-vm/asdf) allows us to use one tool to manage both Elixir and Erlang, and the next time I'm working on a Ruby project, I will probably switch over to using it as well. We can easily install asdf using [Homebrew](https://brew.sh/). ```shell $ brew install asdf coreutils curl git ``` The next important bit is at the bottom of the output stating that you will need to initialize asdf whenever you start your shell session. I ran the following command to add that line to my .zshrc file, but you should add it to the approriate rc file for your shell. ```shell $ echo 'source $(brew --prefix asdf)/asdf.sh' >> .zshrc ``` ## Installing Erlang and Elixir We're almost there! Since asdf relies on language plugins, we have to add those now and any dependencies they might require. ```shell $ brew install autoconf $ asdf plugin add erlang $ brew install unzip $ asdf plugin add elixir ``` Now we want to install the actual languages. The syntax for this is `asdf install `, so we can do the following. ```shell $ asdf install erlang 23.2.5 $ asdf install elixir 1.11.3 ``` If you want to see a list of available versions for each langauge, you can run the command `asdf list all ` Let's make sure that they were successfully installed, running the following commands should produce this output. ```shell $ source ~/.zshrc $ which erl /Users/mitchell/.asdf/shims/erl $ which elixir /Users/mitchell/.asdf/shims/elixir ``` asdf has the concepts of global versions and a local versions, but we are going to focus on the local version concept. Once we navigate into the directory of our project, we can set the version of Erlang and Elixir that we want it to use. ```shell $ cd ~/my-elixir-project $ asdf local erlang 23.2.5 $ asdf local elixir 1.11.3 # Set them globally $ asdf global erlang 23.2.5 $ asdf global elixir 1.11.3 ``` This will add to (or create if there isn't one already) the `.tools-version` file in the root of your project folder. It should now resemble this. ``` erlang 23.2.5 elixir 1.11.3 ``` Boom! You are now ready to get started with Elixir. Checking the version of Elixir should now confirm that your project can find and use it. ```shell $ elixir --version Erlang/OTP 23 [erts-11.1.7] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe] Elixir 1.11.3 (compiled with Erlang/OTP 21) ```

Habits of Successful Projects

Tue, 03 Oct 2017 08:00:00 -04

From Mitchell Hanberg's Blog: Over the course of a project, it is easy to become jaded and to lose track of why your team has certain processes. It's important to stay vigilant to keep those processes from degrading, because you will have trouble finding the cause of a reduction in velocity or quality due to the misunderstanding of how the team is operating. This post details some habits that I've noticed to be invaluable. ## Trying something new Pick something and _execute_. This is especially important when you are giving a new project strategy a trial run, because if you don't follow through then you have no idea if the strategy didn't work. You can't be iterative if you can't learn from your mistakes and you can't learn from your mistakes if you can't identify them. Have a meeting and make some documents that detail the new protocol, so everyone should know what is expected and be able to comply. ## The little things do matter Focusing on rules can seem pedantic but setting expectations will create a consistent, trustworthy environment that optimizes for visibility. If your team is following the project's rules, you can be confident that you know the current state of the project. This passive communication can relieve a heavy mental load that comes with constantly wondering what progress the team is making. If you find your team going through your project board during a stand-up/status meeting and teammates are saying, "Oh, I finished that a week ago" or "Oh, that's blocked on _thing_," you have a problem and need to address it. ## Meetings With the exception of a daily stand-up/status meeting, meetings should take the form of a group activity or should spin off activities. Things should either be _getting done_ or be explicitly delegated to _get done_, the phrasing of the latter is important. This is not the same as saying, "We'll worry about this later." Don't go down rabbit holes, so be comfortable steering a discussion back on track if it has veered off topic. The meeting is not the time to engineer a solution to the problem at hand, but to decide on the direction and determine who is best equipped to tackle it. ## Retrospectives Retros are the time to decide which practices to toss, which to keep, and on which to double down. Care is needed to prevent these meetings from turning into an hour-long venting session that doesn't offer any solutions. During your sprint, write down topics that you'd like to discuss and put them in a centralized place so that others can see them. This gives your teammates time to ponder your topic, making their response more valuable than if you gave them 10 seconds to think it through. --- We love designing, building and deploying, so it's easy to get carried away and forgo process for the sake of getting things done. That's okay, but if you and your team have an "official" protocol you should follow it or exchange it for something that better suits your project's needs.

Using Elm within VueJS

Thu, 17 Aug 2017 22:02:15 +0200

From Maarten van Vliet: Using Elm within VueJS Lately I have been using VueJS a lot. It’s an easy framework to learn and gets results quickly. There is an optional Typescript package to get some much needed typesafety. Overall, I’m pretty happy with it. However, the templates in Vue are where the typesafety breaks down. Typescript just has no way of knowing what’s happening in there, whereas it does have support for JSX/TXS and will supply you with type information in e.

Early look at Rails ActiveStorage

Sun, 13 Aug 2017 22:34:06 +0200

From Maarten van Vliet: I took an early peek at the new Active Storage project in Rails 5.2. It is a built-in solution to handling uploads, something that is all to common in web applications. Also something that is covered by quite a few gems, CarrierWave, PaperClip and Refile for example. These are just the ones I know off the top of my head. At times I have also handled uploads without gems, it’s not that difficult and didn’t warrant the inclusion of another gem for those projects.

Uploading to Google Cloud Storage using Arc and Phoenix

Sat, 05 Aug 2017 22:34:06 +0200

From Maarten van Vliet: In this post I will demonstrate how to upload to Google Cloud Storage using Arc and Arc.Ecto in Phoenix. There are several examples on how to use Arc in combination with S3 or local file uploads but the GCS integration is a bit more unknown. I assume you have an up to date elixir installation and know your way around Phoenix and GCS. mix archive.install https://github.com/phoenixframework/archives/raw/master/phx_new.ez mix phx.new web --no-brunch Follow instructions to configure your postgres credentials in config/dev.

Dynamic image resizing with Google Cloud Functions

Sat, 29 Jul 2017 15:28:27 +0200

From Maarten van Vliet: For a small project I needed dynamic image resizing, meaning I would call an image in an url, append some parameters for resizing and return a smaller image, so something like example.com/image.jpg?w=50&h=50. Now there are several open source projects capable of doing that, most notably Thumbor. However, I wanted to try something new. I recently dabbled a little with Google Cloud Functions and it seemed like a good candidate. However, I feared the initial spin-up time of the functions might be problematic.

Upgrade js dependencies with yarn

Wed, 28 Jun 2017 22:12:44 +0200

From Maarten van Vliet: A quick trick to upgrade the javascript dependencies in your project. Use the command $ yarn upgrade-interactive It will show you an interface to select the packages you want to upgrade. The packages listed in red would be upgraded when you would execute the $ yarn upgrade command. Yellow packages are semver incompatible, meaning that they may be incompatible with your code. Extra caution is needed when upgrading those. You can use space to select the packages, press enter to install them.

Todoist Gem

Fri, 12 May 2017 23:04:18 +0200

From Maarten van Vliet: Todoist gem Todoist

Moneybird Gem

Fri, 12 May 2017 23:04:18 +0200

From Maarten van Vliet: Moneybird gem moneybird

Factuursturen Gem

Fri, 12 May 2017 23:04:18 +0200

From Maarten van Vliet: Factuursturen gem Factuursturen

about

Wed, 10 May 2017 14:37:32 +0200

From Maarten van Vliet: Software consultant Hi, I am Maarten, a full stack web consultant based in Rotterdam. I am good at building scalable products using simple and proven technologies. Technologies I have worked with include: Javascript, Ruby, Elixir, Php, R, Python, Mysql, Postgresql, Elasticsearch, Redis, AWS, GCP. Send me an email :)

Adding Elm to a Rails 5.1 application

Tue, 09 May 2017 22:07:33 +0200

From Maarten van Vliet: Note: Webpacker update Although this tutorial will still work it has been superseded by the addition of Elm to the webpacker gem. See this commit and the entry in the README. The end result is nearly the same. Adding Elm to a Rails 5.1 application The release of Rails 5.1 (http://weblog.rubyonrails.org/2017/4/27/Rails-5-1-final/)has brought some interesting changes for frontend development. Most notably is that it comes with yarn, a tool to manage your javascript dependencies from NPM.

First Dive into Development for VR

Tue, 11 Apr 2017 00:00:00 UTC

From Mitchell Hanberg's Blog: ## Intro Having some free time, I was asked to investigate the current state of Virtual Reality (hardware, development kits, etc) and to attempt build a prototype in order to start building our chops. Going into this, I didn't have any prior experience with VR, 3D modeling, or physics engines and I wasn't sure if I would be able to even get anything to compile, yet I was able to build a small game and deploy it to a VR headset in only a few days. ## The Platforms There are a couple of categories: Desktop VR and Mobile VR. Examples of desktop VR are the Oculus Rift and the HTC Vive. These devices are headsets that are connected to a PC primarily used to play video games that have been optimized for VR. Examples of mobile VR are the Samsung Gear VR (which is powered by Oculus) and Google Daydream. Both of which can only run on certain devices. For our situation, we already had a Gear VR compatible phone (Samsung Galaxy S7), so we went down that path. ## Development What I learned during this experiment is that building a "VR app" is really just creating something in a game engine, enabling VR support, and then building it for whatever platform. The VR layer of the whole process is rather thin, it's more about keeping VR in mind during development in order to really take advantage of the platform. Most of the VR platforms have support for Unity and Unreal Engine, so I chose Unity and followed their basic [tutorial](https://unity3d.com/learn/tutorials/projects/roll-ball-tutorial) (a roll-a-ball game, in which the player moves a ball to collect objects), just to get something up and running. Unity has an amazing amount of documentation available, so getting it installed and commencing on the tutorial game was a fairly painless process. I was able to get the tutorial finished in a couple of hours. ![picture](/images/roll-a-ball-screenshot.png) At this point it was time to get it on the phone and be able to view it in the headset. We hadn't bought the actual Gear VR headset yet, but we were able to find a 3rd party headset somewhere in the office. The steps to deploy were pretty simple 1. Install the Android SDK 2. Point Unity to the path of the SDK 3. Create an Oculus .osig and copy it to the appropriate folder in your project 4. Configure the appropriate build settings 5. Hit "Build and Run" Normally the phone will have a "Insert into headset" message and won't display your app until it's inserted, but after enabling developer mode from within the "Gear VR Service", you are able to start the app and view it with a 3rd party headset. The Gear VR headset has a touchpad on it, which allows you to interact with the app while viewing it with the headset. The headset I was using did not have such capabilities and I had yet to create a work around, so at this point you couldn't actually play the game while wearing the headset. ## Retrospective The key aspects of creating content for the Virtual Reality platform were not what I expected and it feels cool to play around with a game engine. The business opportunities for VR are still being uncovered and it'll be interesting to see how the platform evolves.

Leaving Your Legacy

Thu, 09 Mar 2017 09:00:00 EST

From Mitchell Hanberg's Blog:

Introduction

At one point or another, we all will work on a legacy project. You're between projects and you get put on an internal effort, you're starting a new project with a client and inherit the old codebase, or something or another.

I was fortunate enough to get placed directly on a project when I joined my company, rich with modern coding practices. Code review, scrum-style backlog and story mapping, and a team full of seasoned engineers who were all familiar with the codebase.

Until it was my turn to say goodbye to the team and hello to new opportunities, and in the meantime, I would concentrate my efforts on one of our internal projects.

This post serves as an outlet for my experience.

Important

Team size = me.

The Stack

Before starting on this project, I had an interest in exploring a new stack of technology, particularly Ruby web development with the Ruby on Rails framework. I had previously worked heavily in the .NET web stack and wanted to try my hand at something different.

And then just like that, I'm told I have the opportunity to work on a Rails project in a professional setting, woo! I'm excited.

Working through my first task, naturally, I do some googling. I notice that everything I'm seeing online looks totally different than what I'm seeing in the codebase. Eventually, I come to the realization that I'm working on Rails 3.2 and Ruby 1.9, a 5-year-old framework and a 10-year-old language. All I know about Ruby at this point has been deprecated for years (to a degree, the general syntax is similar).

Learning the ins and outs of an old version of a tool just seems backward, especially if you haven't used that tool before. Is upgrading to the latest versions worth it for this project? Not really, but that seems to be part of the problem.

Testing

When I first started exploring the codebase, I was excited to see how one went about testing in Ruby/Rails, only to find that half of the tests were failing.

I spent a week ironing out the tests. With test failures ranging from a lack of test fixtures to commented out blocks of deprecated code from a framework upgrade that never got finished.

Testing stops being useful when you can't trust your tests.

This is where the difficulties of working on an internal project start to crop up, you see all these broken windows, but don't have the drive to fix them. You become desensitized to the lower quality of code and the codebase suffers for it.

I fixed all the tests, but at this point, I ask myself, are these tests even valuable? What are they testing?

Deployment

Previously there was Jenkins integration with building and deployment using CloudFoundry, but this was not maintained and no longer works. Therefore, all staging and production deployments must be done manually

This was an actual quote from the project's wiki page (until I deleted it). I wasn't surprised by a defunct continuous integration setup, but that the expected deployment process was to manually copy the files.

I did not think that this project needed some fancy system for deployment, but that just seemed wrong.

I then experimented with just replacing the code on the server with a clone of the repository, and it deploy all it required was a git pull. Not much effort was put into this, but it was simple to implement and simple to use.

Decay

This is the general theme, each time a new developer joins the project temporarily they will leave behind something corrosive, slowly decaying the project. Even experienced engineers can write some bad code if the circumstances are begging for it.

Out-of-date comments are left to rot, wikis are stale and inaccurate, and tests break and remain broken. Now this happens over time, and I'm not sure if you'd be able to recognize it happening in real time.

In order to stop (or at least slow down) the decay is to maintain verbose documentation. Commit messages need to be wordy and the wiki (if you have one) needs to be awfully explicit. Now I don't think it needs to be written for someone who isn't a developer, but it at least should be written for someone who has no experience in any of the project stack.

Example of a commit message that is not helpful

fixed brokn thing .

Example of a commit message that is helpful

Fixed broken pagination after filtering list
 * Code was attempting to filter during pagination, now 
   the list filters completely and then paginates the filtered list
 * Updated the gem used for pagination from v0.5.1 to v1.0.1

I even think a project journal would be beneficial. After each task is finished, the developer will log everything that went into the task, including reasoning, failed attempts and possibly even short explanation of how a certain library was utilized. Anything that isn't written down is essentially lost for eternity, so any epiphanies you had are useless if you don't write them down for the next developer down the line.

Conclusion

Working with legacy code is inevitable, but with a little TLC, you can make it less painful for those who will work with it after you.

A couple takeaways from this experience are

Always leave the project (or code, documentation, etc.) in a better condition than when you joined. Take the bit of extra time to jot down broken windows you see or valuable (yet not expensive) improvements you can make, to either fix after your task or during.
Find yourself a healthy level of criticality, don't assume all the code is crap, but don't assume that it's all great code.
Ask questions. If you have to track down someone who worked on the project 4 years ago, do it. You're not going to find their rationale for a design decision on Stack Overflow.

If You Don't Have Anything Valuable To Say... Say It Anyways

Tue, 28 Feb 2017 09:00:00 EST

From Mitchell Hanberg's Blog:

What does this mean?

In the professional world, feedback is incredibly important and can vastly beneficial, but sometimes our fear of criticism can stop you from sharing, which then inhibits you from learning.

There's nothing I hate more than being wrong, more so than others knowing I was wrong. Being able to leverage others knowledge to accelerate your own growth is a key to success (in my opinion, this is the part where you can tell me I'm wrong).

Obviously the title of the post is insinuating that you should make a blog and write articles about the stuff you are up to or any remarkable experiences, but I think it also applies to other areas of your life. It's not just about saying or writing, but it's also about doing, and this is something with which I struggle.

You'll never finish if you don't start

Many people never start a project because they don't want to get it wrong; they're afraid to build something that doesn't work because it'll mean that they're dumb.

Wrong

2021-06-28T21:41:03-04:00

From Stratus3D:

Guide to Tracing in Erlang

2021-08-24T21:48:30-04:00

From Stratus3D:

I’ve spent a lot of time debugging Elixir and Erlang applications over the last 5 years and decided to share what I’ve learned here. I started writing this blog post in April of 2017 and wasn’t inspired to finish it until watching Jeffery Utter’s Debugging Live Systems on the BEAM talk about a month ago. If you’d prefer a more concise presentation of Erlang tracing I suggest you watch that talk instead of reading this.

The first thing to understand when debugging Erlang applications is that Erlang’s concurrency greatly influences how debugging is done. While Erlang does have a traditional debugger its breakpoints pause process execution and may cause other processes in the system to crash if they are waiting on a message from the process that has been paused. Tracing on the other hand can be done under any circumstances and provides just as much information as a typical debugger. Tracing is also significantly more flexible than breakpoint debugging as it doesn’t interfere with process execution and can gather data from multiple processes at once.

Visualizing Backoff Functions With Gnuplot

2022-11-24T09:43:33-05:00

2021-10-20T12:57:49-04:00

From Stratus3D:

I recently published an article on the Code for RentPath blog about a new tool I created during SpawnFest this year.

SpawnFest is an annual 48 hour online contest where teams try to build the best BEAM-based application, as determined by the judges based on certain criteria. In this blog post I am going to introduce the new tool I created during SpawnFest.

eFlambé is a tool for rapidly profiling Erlang and Elixir code. It is intended to be one of the first tools you reach for when debugging a performance issue in your Elixir or Erlang application. With a single command you can visualize your code’s performance as an interactive flame graph in your flame graph viewer of choice. It’s written in Erlang and published to hex.pm.

From ❖ |> 🌢:

Old Hardware I Love

2022-12-18T17:47:50-05:00

From Stratus3D:

Recently I got to thinking about the electronic devices I use regularly and love. I realized that many of the devices I enjoy using are by many people’s standards pretty old for electronics. I’ve always been thrifty and don’t like replacing electronics with new ones until they break. In this blog post I’m going to highlight three old devices that I enjoy using for one reason or another.

Open Source is Not About You

2020-01-18T13:32:00+00:00

From keathley.github.io: Rich Hickey posted this gist back in 2018 about the entitlement of people who use open-source software. I’m not going to re-iterate his points and instead suggest that you give it a read. But, I’ll leave you with one of my favorite quotes:

What I Learned Building a CLI App in Rust

2023-07-18T07:33:14-04:00

From Stratus3D:

It’s been 8 years since I learned Elixir and since then I have not tried to learn another programming language. I have now decided to learn a systems programming language, and it seems like a good time to be learning about them. New languages like Vale and Rust combine the memory safety of a high-level language with the performance of C. Rust is very popular today but there are many other new systems languages with similar characteristics. Zig, Vlang, Nim are a few that come to mind.

Erlang/OTP 29.0 Release Candidate 2

2026-03-18T00:00:00+00:00

From Erlang/OTP | News: OTP 29.0-rc2

Dynamic Nested Function Call

2021-02-18T00:00:00+00:00

From ❖ |> 🌢:

Strong Types Should Have Been Named Strong Hypes

2020-01-18T00:00:00+00:00

From ❖ |> 🌢:

Debugging a Slow Starting Elixir Application

One of the big benefits of static websites is simplicity. Static websites are simple so there is much less to worry about. There are no login credentials to be compromised. There is no dynamic content that must be stored and displayed. There is no danger of a bug in the code allowing SQL injections. But there are still things that should be done to secure a static website. In this blog post I will list some of the important things that still need to be done to provide a secure static website.

Show All Telemetry Events in Erlang and Elixir

2023-10-15T14:05:37-04:00

From Stratus3D:

Telemetry is an Erlang library for dynamically dispatching events to event handlers. Many popular Erlang and Elixir packages use the Telemetry library to emit events. Telemetry event data typically ends up in logs or metric databases like Prometheus.

Events are identified by name. You can register a function as an event handler and get invoked when events with a specific name occur. A name or list of names must be specified when registering a handler using the telemetry:attach/4 and telemetry:attach_many/4 functions.

Benefits of Living Without a Smartphone

2021-05-15T12:11:11-04:00

From Stratus3D:

2021-08-11T19:17:52-04:00

From Stratus3D:

If you’ve ever used the dbg module in Erlang you’ve seen the esoteric names of the functions it exports. I recently watched Jeffery Utter’s excellent ElixirConf talk on Debugging Live Systems on the BEAM. In the talk when he covers the dbg:tpl/3 function he guesses that it might stand for "tuple". This reminded me that I didn’t know what most of the functions names in the dbg module stood for, even though I learned how to use dbg years ago. This got me searching for the meanings behind the dbg function names.

Testing your README.md

2021-12-11T11:00:00+00:00

From keathley.github.io: I’ve wanted a good way to test READMEs in elixir. I started building something myself before my good friend Wojtek pointed out that there was a simple solution.

Asdf Performance

From Notes to self: If you are building AI-powered applications in Ruby on Rails, you might have come across Informers or Transformers.rb gems for transformer inference. Here’s how to improve the production deployment of their models in Kamal setups.

Review of the Alcatel GO Flip 2 and KaiOS

2021-07-09T19:05:23-04:00

From Stratus3D:

I’ve posted several off-topic blog posts this year and this is another one. Perhaps it is more relevant than the others as I list the issues with KaiOS software and the software limitations of my feature phone.

From Notes to self: Here’s how to implement autosaving for inline input fields the Hotwire way.

The Best Book on Code Reviews

2022-06-08T11:34:16-04:00

From ❖ |> 🌢:

Reducing Eye Strain

2022-05-02T20:31:07-04:00

From Stratus3D:

Over the last couple years I’ve experienced some symptoms of eye strain after a long day at the computer. I spend most of my day in front of the computer and I want my setup to be as healthy for my eyes as possible. I began reading what I could find on the topic. I wrote this post to document the things I learned and the changes I made as a result.

Asdf Performance Improvements

2025-05-02T14:15:30-04:00

Function/Variable Ambiguity in Elixir

2022-04-01T17:25:49-04:00

From Stratus3D:

Variable syntax is one of the big differences between Erlang and Elixir that I encountered when learning Elixir. Instead of having to start each variable name with an uppercase letter, a lowercase letter must be used. This change in syntax seems like an improvement - after all most mainstream programming languages require variables to start with a lowercase letter, and lowercase is generally easier to type. However, a deeper look at this syntax choice reveals some significant downsides that I want to present here.

Integrating Phoenix LiveView with JavaScript and AlpineJS

2020-07-01T16:00:57-07:00

From Patrick Thompson:

Understanding Vim Insert Completion

2025-12-01T09:15:08-05:00

From Stratus3D:

I’ve been using Vim for years but Vim’s built-in insert mode content completion is something I only recently took the time to learn. In this blog post I’m going to share how I’ve configured insert mode completion using only features built into Vim 9.

Review of the Kinesis Freestyle Edge Keyboard

2024-01-01T09:15:55-05:00

From Stratus3D:

In August I bought a Kinesis Freestyle Edge keyboard off of eBay. I’ve been using it for about four months now, and I’m typing this review on it. I’d been wanting to try out a split keyboard for a long time but didn’t want to spend a lot of money on one. Good quality split programmable keyboards start at around $200. The Freestyle Edge I found on eBay was new and cost only $80.

The Problem With Elixir’s `with`

2022-06-01T07:47:46-04:00

From Stratus3D:

Summary: Return values from different expressions in a with block can only be distinguished by the shape of the data returned. This creates ambiguity in with 's else clauses that make code harder to understand and more challenging to modify correctly.

with has existed in Elixir since version 1.2 and is widely used. But there are downsides to this construct. In this blog post I’ll explore the problems caused by use of with in a codebase. I’ll assume you know how with works and have read the docs so I will skip over the basics of how it works.

Unveil Erlang Code of Your Elixir Project

2017-09-01T00:00:00+00:00

From ❖ |> 🌢:

Pattern Matching Empty MapSets

2019-03-01T00:00:00+00:00

From ❖ |> 🌢:

10 things you, as a buddy, should know whenever a new developer joins your team

2021-02-01T00:00:00+00:00

From Patryk Bak - a programming blog: It’s a day like any other one. Focused on your work, you suddenly notice someone who has walked into the office and is standing confused. At this point, you realize that he’s probably a new developer who’s joining your team today.

Syntax Highlighting in PowerPoint

2022-01-01T00:00:00-05:00

From Stratus3D:

Back in 2014 I wrote a blog post on inserting code samples into PowerPoint slides with syntax highlighting. It’s been about 8 years and things have changed. Using GitHub Gist no longer works for me.

I’ve found a better way to apply syntax highlighting to code for PowerPoint that also works for LibreOffice Impress with no differences. Both applications expect code in Rich Text Format. The only downside to this approach is you’ll need to have Python and a Python package installed for this to work.

Finitomata Marries Ecto

2023-01-01T00:00:00+00:00

From ❖ |> 🌢:

Beambloggers Webring

Injecting tracing the hot way

Hacking on the Nerves Starter Kit in Malaga

Shipping grayscale photos at small scale

Goatmire 2, announced

Buying the Kinesis Advantage 360 keyboard was a mistake

Conference Report: Goatmire Elixir 2025

Booting 5000 Erlangs on Ampere One 192-core

500 virtual Linux devices on ARM 64

Delta support - A tale of two firmware versions

Making of an Elixir conference

How to work with XML documents in Elixir using xmerl

Elixir is not owned by Big Tech

Keep this in mind when changing scrollbar colors

The implications of Astro's HTML streaming

Code BEAM America 2025

How to set up unit tests for Astro components

The Elixir Shirt

From big Kubers down to small GenServers

How to clamp the lightness of a relative color in CSS

Voice Activity Detection in Elixir and Membrane

Bodging GenServers Together

How I use Erlang Hot Code Updates

Dependencies vs. devDependencies for JavaScript apps

A Brief History of LLMs

Anatomy of Embedded Elixir

Putting code on a Nerves device

To Nerves from Elixir

Catching up with Elixir

I've Joined the Official Elixir LSP Team

How to add CSS rules only in the test env in your Phoenix app

Rewriting a Vue app to Astro

Newsletter issue, adept adoption

Validate and Transform Your Data with Schematic

Pet Peeves

Automated accessibility testing for Elixir web applications

Create Your Own Neovim Distribution

The Future Stack

How to change your local timezone on a mac to debug date-related JavaScript tests

Chatting, Sharing (& Shots) in Chattanooga - GigCity 2024 report

Unpacking Elixir - IoT & Embedded with Nerves

9 signs your frontend code has quality issues that affect your users

How to prevent WebStorm from removing trailing spaces from one specific file?

Fundamentals of Object Storage

Modern Format on Save in Neovim

A great music system

Music library #

Hardware #

Playing music #

Discovery #

Physical collection management and notes #

Too much? #

Challenges of local-first LLMs

How to format Elixir doctests?

How to format Elixir code in Markdown code blocks?

Unpacking Elixir: Phoenix

Do not run `mix test || mix test --failed`

Unpacking Elixir: The Actor Model

Ergonomic Remote Development

Tailscale

Clipboard

TUI Apps

Scripting

Opening your web browser

Web Development

Tailscale

SSH Port Forwarding

Signing Git Commits

Conclusion

Unpacking Elixir: Observability

Unpacking Elixir: Resilience

Create a sorted Index in Ecto

Start async task under our application Supervision tree

Unpacking Elixir: Real-time & Latency

Unpacking Elixir: Syntax

Unpacking Elixir: Concurrency

Arriving Somewhere

The many states of Elixir

Scripting with Elixir

Why do ML on the Erlang VM?

Music library

Hardware

Playing music

Discovery

Physical collection management and notes

Too much?

Planting a seed

Unexpected changes

Introspection