Skip to content

Latest commit

 

History

History
3087 lines (2387 loc) · 270 KB

Elixir.markdown

File metadata and controls

3087 lines (2387 loc) · 270 KB
Raw

My Elixir, Erlang, and other BEAM Resources - James Lavin

DESCRIPTION

Links to resources I have found useful or think might be helpful to future me or Elixir/Erlang/BEAM developers like me.

CONVERTING BETWEEN ELIXIR & ERLANG

ERLANG ECOSYSTEM FOUNDATION (EEF)

SYSTEM DESIGN, OPERATION, & RELIABILITY

ALPACA

BEAM

BEAM - COLLABORATION

BEAM - COMPILER

BEAM - DEBUGGING

BEAM - DSL FOR LANGUAGES

BEAM - INTEROPERABILITY

BEAM - PERFORMANCE

CLOJERL

ELIXIR

ELIXIR - GETTING STARTED

ELIXIR - GETTING STARTED (💰NON-FREE💰)

ELIXIR - GENERAL

ELIXIR - POPULAR LIBRARIES

ELIXIR - 1.14

ELIXIR - 1.13

ELIXIR - 1.12

ELIXIR - 1.11

ELIXIR - 1.10

  • Elixir v1.10 released
  • Elixir Update - José Valim (Code BEAM V 2020)
  • Changelog for Elixir 1.10

    • "Requires Erlang/OTP 21+, allowing Elixir to integrate with Erlang/OTP's new :logger. The logger level, logger metadata, and all log messages are now shared between Erlang and Elixir APIs."

    • is_struct(term)

    • is_map_key(map, key)

    • Release overlays: "Often it is necessary to copy extra files to the release root after the release is assembled. This can be easily done by placing such files in the rel/overlays directory. Any file in there is copied as is to the release root. For example, if you have place a rel/overlays/Dockerfile file, the Dockerfile will be copied as is to the release root"

    • Enum.sort (and related functions) support :asc and :desc:

      iex> Enum.sort(["banana", "apple", "pineapple"], :asc)
["apple", "banana", "pineapple"]
iex> Enum.sort(["banana", "apple", "pineapple"], :desc)
["pineapple", "banana", "apple"]

    • Enum.sort (and related functions) support semantic comparisons:

      iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], Date)
[~D[2019-12-31], ~D[2020-01-01]]
iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], {:desc, Date})
[~D[2020-01-01], ~D[2019-12-31]]

    • "We will deprecate the use of Application.get_env at compile-time," like the following, which sets @db_host at compile-time:

      defmodule MyApp.DBClient do
  @db_host Application.get_env(:my_app, :db_host, "db.local")
  def start_link() do
    SomeLib.DBClient.start_link(host: @db_host)
  end
end

      Which could instead set the value at runtime by putting the call to Application.get_env/3 inside an ordinary function:

      defmodule MyApp.DBClient do
  def start_link() do
    SomeLib.DBClient.start_link(host: db_host())
  end
  defp db_host() do
    Application.get_env(:my_app, :db_host, "db.local")
  end
end

      If you really want to set that value at compile-time, you'll need to say so explicitly with @db_host Application.compile_env(:my_app, :db_host, "db.local"), which you can now use

    • Compiler tracing improvements

    • More Calendar data type improvements

    • Timezone-related functions, like DateTime.now/2, DateTime.shift_zone/3, and NaiveDateTime.local_now/0.

    • The Code module's string_to_quoted/2 function includes new options, :token_metadata and :token_metadata, for Elixir AST parsing

    • The ExUnit library's CaptureIO module now works with concurrent tests

ELIXIR - 1.9

  • Elixir v1.9 released
  • Changelog for Elixir 1.9
    • Releases: "A release is a self-contained directory that consists of your application code, all of its dependencies, plus the whole Erlang Virtual Machine (VM) and runtime. Once a release is assembled, it can be packaged and deployed to a target as long as the target runs on the same operating system (OS) distribution and version as the machine running the mix release command."
      • Created via MIX_ENV=prod mix release
      • Assembled in _build/prod/rel/my_app
      • Within _build/prod/rel/my_app, bin/my_app is the entry point to your app
      • bin/my_app start, bin/my_app stop, bin/my_app restart start & stop the app
      • bin/my_app rpc COMMAND runs COMMAND as a remote procedure call (RPC)
      • bin/my_app remote connects you to the running app via an Erlang console
      • bin/my_app eval COMMAND starts your app fresh, runs COMMAND, and then shuts everything down
      • bin/my_app daemon starts your app as a daemon on a Unix-like system
      • bin/my_app daemon_iex starts your app as a dameon on a Unix-like system within an iex shell
      • bin/my_app install installs your app as a service on Windows machines
    • Release benefits:
      • Releases run in embedded mode, which loads all modules at startup, rather than interactive mode, which loads a module dynamically when it is first used at runtime
      • Releases are self-contained (Elixir and Erlang aren't needed on the target machine
      • Releases contain only compiled code, not source code
      • Tree-shaking removes unused Erlang & Elixir standard libraries
      • You can deploy a release to multiple machines, each with different configurations
    • Release hooks
      • config/config.exs (and config/prod.exs) provides build-time/compile-time application configuration, which is executed when the release is assembled
      • config/releases.exs provides runtime application configuration. It's executed every time the release boots and is further extensible via config providers
      • rel/vm.args.eex: Template file copied into every release and providing static configuration of the Erlang Virtual Machine and other runtime flags
      • rel/env.sh.eex and rel/env.bat.eex: Template files copied into every release and executed on every command to set up environment variables, including ones specific to the VM, and the general environment
    • New Config module
    • ~U sigil for creating UTC DateTime values
    • New functions in the System and File modules

ELIXIR - 1.8

  • Elixir v1.8 released

  • Changelog for Elixir 1.8

    • Custom inspect() for structs: By default, inspect(user) (where user is a strut) will display all fields in user. If you want to exclude some fields, you can derive your Inspect protocol implementation and exclude the fields you don't wish to display. For example, the following will exclude :email and :encrypted_password: 
      defmodule User do
  @derive {Inspect, only: [:id, :name, :age]}
  defstruct [:id, :name, :age, :email, :encrypted_password]
end
      or 
      @derive {Inspect, except: [:email, :encrypted_password]}

    If you do this, a User struct will be printed as #User<id: 1, name: "Jane", age: 33, ...>

    • A new Calendar.TimeZoneDatabase behaviour, allowing developers to bring in their own time zone databases or use the provided Calendar.UTCOnlyTimeZoneDatabase.
    • Process dictionary's $callers key now tracks which code spawned a task. Previously, if your code called Task.Supervisor.start_child(MySupervisor, task_specification), the actual parent (recorded in $ancestors) of the task would be the supervisor, as the supervisor is the one spawning it and the relationship between your code and the task is lost. Now, we record in $callers that your code is the caller of the spawned task.

ELIXIR - 1.7

  • Elixir v1.7 released
  • Changelog for Elixir 1.7
    • Document metadata can be added to @doc, @moduledoc, and @typdoc, e.g.: 
      @moduledoc "A brand new module"
@moduledoc authors: ["Jane", "Mary"], since: "1.4.0"
    • Side-effect-free way to retrieve the stacktrace. The following logs and re-raises the __STACKTRACE__: 
      try do
  ... something that may fail ...
rescue
  e ->
    log(e, __STACKTRACE__)
    reraise(e, __STACKTRACE__)
end
    • Full integration with OTP 21.0's new :logger module. See Erlang/OTP 21's new logger, Logging, and Logger Cookbook for more information
    • Logger.Translator has been improved to export metadata, allowing custom Logger backends to leverage information such as:
      • :crash_reason: two-element tuple with the throw/error/exit reason as first argument and the stacktrace as second
      • :initial_call: initial call that started the process
      • :registered_name: process registered name as an atom
    • "We recommend Elixir libraries that previously hooked into Erlang's :error_logger to hook into Logger instead, in order to support all current and future Erlang/OTP versions"
    • Logger now evaluates its arguments if/when the message is logged (which it may not be, for various reasons)
    • :compile_time_purge_matching removes log calls with specific compile-time metadata. For example, to remove all logger calls from application :foo with level lower than :info, as well as remove all Logger calls from Bar.foo/3, use the following configuration: 
      config :logger,
  compile_time_purge_matching: [
    [application: :foo, level_lower_than: :info],
    [module: Bar, function: "foo/3"]
  ]
    • mix test --failed re-runs all tests that failed last time they ran
    • mix test --cover summarizes test coverage

ELIXIR - 1.6

  • Elixir v1.6 released
  • José Valim- Introducing HDD: Hughes Driven Development (Lambda Days 2018)
  • Changelog for Elixir 1.6
    • mix format will automatically format your code. A .formatter.exs file may be added to your project root for rudimentary formatter configuration
    • New DynamicSupervisor module allows starting & stopping children dynamically
    • @since indicates the API version into which the function or macro was first added, and @deprecated marks the function/macro as deprecated: 
      @doc "Breaks a collection into chunks"
@since "1.0.0"
@deprecated "Use chunk_every/2 instead"
def chunk(collection, chunk_size) do
  chunk_every(collection, chunk_size)
end
    • mix xref now warns when your code calls code marked @deprecated
    • defguard and defguardp for naming your guard clauses, e.g.: 
      defguard is_drinking_age(age) when age >= 21

def serve_drinks(%User{age: age}) when is_drinking_age(age) do
  # Code that serves drinks!
end
    • In iex, typing t Enum. and hitting <Tab> will autocomplete only the types in Enum
    • In iex, typing b GenServer. and hitting <Tab> will autocomplete only the behaviour callbacks
    • In iex, breakpoints can now use pattern matching and guard clauses, e.g.: break! SomeFunction.call(:foo, _, _)
    • To find all callers of a given module or function in an umbrella: mix xref callers SomeModule --include-siblings
    • mix xref:
      • Output general statistics about the dependency graph: mix xref graph --format stats
      • Get all files that depend on lib/foo.ex: mix xref graph --sink lib/foo.ex --only-nodes
      • Get all files that depend on lib/foo.ex at compile time: mix xref graph --label compile --sink lib/foo.ex --only-nodes
      • Get all files lib/foo.ex depends on: mix xref graph --source lib/foo.ex --only-nodes
      • Limit statistics to compile-time dependencies: mix xref graph --format stats --label compile
    • mix test --slowest N lists your slowest N tests
    • New mix profile.eprof task provides time-based profiling, complementing the existing mix profile.cprof (count-based) and mix profile.fprof (flame-based)

ELIXIR - 1.5

  • Elixir v1.5 released
  • The Feature That No One Knew About in Elixir 1.5 - José Valim (Elixir.LDN 2017)
  • Changelog for Elixir 1.5
    • Non-quoted atoms can include UTF-8 characters, like :こんにちは世界 (see: Unicode Syntax)
    • Non-quoted variables can include UTF-8 characters, like saudação = "Bom dia!". josé, _age, まつもと, _42, and адрес are all valid variable names
    • iex improvements:
      • iex autocomplete
      • exports/1 lists all exports (functions and macros) in a given module
      • open/1 opens the source of a module or function directly in your editor. For example, open MyApp.Module
      • runtime_info/0 prints general information about the running system, such as number of cores, runtime version, allocation of memory in the VM and more
    • IEx breakpoint system for code debugging has these new functions:
      • break!/2 sets a breakpoint for a given Mod.fun/arity
      • break!/4 sets a breakpoint for the given module, function, arity
      • breaks/0 prints all breakpoints and their IDs
      • continue/0 continues until the next breakpoint in the same process
      • open/0 opens editor on the current breakpoint
      • remove_breaks/0 removes all breakpoints in all modules
      • remove_breaks/1 removes all breakpoints in a given module
      • reset_break/1 sets the number of stops on the given ID to zero
      • reset_break/3 sets the number of stops on the given module, function, arity to zero
      • respawn/0 starts a new shell (breakpoints will ask for permission once more)
      • whereami/1 shows the current location
    • blame/3 in the Exception module
    • Streamlined supervised child specs
    • Agent, Registry, Task, and Task.Supervisor have been updated to include a child_spec/1 function, allowing them to be used directly in a supervision tree. See description in Supervisor module
    • New @impl attribute, which indicates that the function implements a callback, an assertion the compiler checks: 
      defmodule MyApp do
  @behaviour Plug

  @impl true
  def init(_opts) do
    opts
  end

  @impl true
  def call(conn, _opts) do
    Plug.Conn.send_resp(conn, 200, "hello world")
  end
end
      @impl true could also specify which behaviour defines the callback, e.g., @impl Plug
    • More Calendar functions

ELIXIR - 1.4

  • Elixir v1.4 released
  • Using the Registry in Elixir 1.4 - Adam Mokan
  • Changelog for Elixir 1.4
    • New Registry module is a local (single-node), decentralized and scalable key-value process storage 
      iex> Registry.start_link(:unique, MyRegistry)
iex> {:ok, _} = Registry.register(MyRegistry, "hello", 1)
iex> Registry.lookup(MyRegistry, "hello")
[{self(), 1}]
    • Registry can be used to register and access named processes using the {:via, Registry, {registry, key}} tuple 
      {:ok, _} = Registry.start_link(keys: :unique, name: Registry.ViaTest)
name = {:via, Registry, {Registry.ViaTest, "agent", :hello}}
{:ok, _} = Agent.start_link(fn -> 0 end, name: name)
Registry.lookup(Registry.ViaTest, "agent")
#=> [{self(), :hello}]
    • More Calendar functions
    • Task module now includes Task.async_stream, which allows lazy steam processing with configurable max_concurrency. Replace: 
      collection
|> Enum.map(&Task.async(SomeMod, :function, [&1]))
|> Enum.map(&Task.await/1)
      with 
      collection
|> Task.async_stream(SomeMod, :function, [], max_concurrency: System.schedulers_online)
    • Task.Supervisor includes async_stream/4 and async_stream/6, which can ensure concurrent tasks are spawned under a given supervisor.
    • mix.exs no longer requires listing all project dependencies under :applications but infers these dependencies, except for apps that are part of Elixir or Erlang, which should now be specified under :extra_applications. E.g., instead of: 
      def application do
  [applications: [:logger, :plug, :postgrex]]
end
      only :logger (because it's built into the language) must be listed: 
      def application do
  [extra_applications: [:logger]]
end
    • App dependencies that should not be required by your running app can be listed with runtime: false, e.g. 
      {:distillery, "> 0.0.0", runtime: false}
    • Distribute CLI apps written in Elixir as escripts published to Hex. For example, anyone can install hex_docs from Hex by running mix escript.install hex ex_doc. After adding ~/.mix/escripts to your PATH, running ex_doc is as simple as running ex_doc.

ELIXIR - 1.3

  • Changelog for Elixir 1.3
    • Warning if constructs like if, case and friends assign to a variable that is accessed in an outer scope
    • New modules: Calendar, Date, Time, NaiveDateTime, and DateTime
    • Date sigil: ~D[2016-05-29]
    • Time sigil: ~T[08:00:00] and ~T[08:00:00.285]
    • NaiveDateTime sigil: ~N[2016-05-29 08:00:00]
    • New Access module accessors, like update_in/3: 
      iex> user = %{name: "john",
...>          languages: [%{name: "elixir", type: :functional},
...>                      %{name: "c", type: :procedural}]}
iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
%{name: "john",
  languages: [%{name: "ELIXIR", type: :functional},
              %{name: "C", type: :procedural}]}
    • mix xref to perform cross-reference checks on your code
      • mix xref unreachable would notice ThisModuleDoesNotExist.foo(1, 2, 3)
      • mix xref callers Foo finds all places in your code that a function from the module Foo is called
    • mix app.tree lists all applications your current project must start to boot
    • mix deps.tree lists all your current project's direct dependencies and recursive dependencies
    • mix escript.install (and mix escript.uninstall) lets you install escripts at ~/.mix/escripts (which must be added to your PATH environment variable)
    • mix test --stale will run only tests whose results could have changed since you last ran mix test --stale
    • In ExUnit, assert left == right now displays diffed output on test failure
    • ExUnit allows libraries like QuickCheck to register new test types
    • ExUnit allows grouping tests into a (non-nested) describe block and run only a specific describe block (with mix test --only describe:"String.capitalize/2")
    • ExUnit describe blocks aren't nested because "we want developers to build on top of named setups. For example:" 
      defmodule UserManagementTest do
  use ExUnit.Case, async: true

  describe "when user is logged in and is an admin" do
    setup [:log_user_in, :set_type_to_admin]

    test ...
  end

  describe "when user is logged in and is a manager" do
    setup [:log_user_in, :set_type_to_manager]

    test ...
  end

  defp log_user_in(context) do
    # ...
  end
end

ELIXIR - 1.2

  • Elixir v1.2 released
    • Erlang 18 support
    • Improvements to Map & MapSet. Stop using Dict, DictHash, Set, and SetHash
    • Multi-aliases/imports/require: alias MyApp.{Foo, Bar, Baz}
    • Variables in Map keys: %{key => value}
    • Pin operator in map keys: %{^key => value} = %{key => value}
    • Pin operator in function clauses: fn ^key -> :ok end
    • with special form to match on multiple expressions: 
      with {:ok, contents} <- File.read("my_file.ex"),
     {res, binding} <- Code.eval_string(contents),
     do: {:ok, res}
    • i/1 helper in IEx, which allows developers to retrieve information about any data type
    • Umbrella applications can share both build and configuration files, drastically reducing compilation times 
      build_path: "../../_build",
config_path: "../../config/config.exs",
    • Mix is now able to fetch and compile Rebar 3 dependencies
  • Changelog for Elixir 1.2
  • Elixir 1.2 and Elixir in Action

ELIXIR - ACTOR MODEL

ELIXIR - ADOPTION

ELIXIR - ALGEBRAIC DATA TYPES

ELIXIR - ATLAS

ELIXIR - AUTHENTICATION - ASSENT

ELIXIR - AUTHENTICATION - POW

ELIXIR - AUTHENTICATION - PHX.GEN.AUTH (SEMI-OFFICIAL)

ELIXIR - AVIA

ELIXIR - BLOGS & YOUTUBE CHANNELS

ELIXIR - BOOKS

ELIXIR - CACHING

ELIXIR - CHARTS & GRAPHS

ELIXIR - CHARTS & GRAPHS - CONTEX

ELIXIR - CHARTS & GRAPHS - GGITY

ELIXIR - CHARTS & GRAPHS - TUCAN

ELIXIR - CHARTS & GRAPHS - VEGALITE

ELIXIR - CLIENTS

ELIXIR - CLIENTS - CASSANDRA CLIENTS

ELIXIR - CLIENTS - HTTP CLIENTS

ELIXIR - CLIENTS - SPARQL CLIENTS

ELIXIR - CLIENTS - SSH CLIENTS

ELIXIR - CODE EXAMPLES

ELIXIR - CODE QUALITY

ELIXIR - CODE QUALITY - MODULARITY

  • Boundary: Library that helps manage and restrain cross-module dependencies: Github

ELIXIR - COMPILER

ELIXIR - CORS

ELIXIR - COURSES (💰NON-FREE💰)

ELIXIR - DATA ANALYSIS

ELIXIR - DATA PIPELINES

ELIXIR - DATA PIPELINES - BROADWAY

ELIXIR - DATA PIPELINES - GENSTAGE & FLOW

ELIXIR - DATE & TIME

ELIXIR - DEBUGGING

ELIXIR - DEBUGGING - ORION

ELIXIR - DEBUGGING - PRY

ELIXIR - DEBUGGING - VISUALIXIR

ELIXIR - DEPLOYMENT

ELIXIR - DEPLOYMENT - AWS

ELIXIR - DEPLOYMENT - BOOTLEG

ELIXIR - DEPLOYMENT - CLUSTERING

ELIXIR - DEPLOYMENT - CLUSTERING - LIBCLUSTER
ELIXIR - DEPLOYMENT - CLUSTERING - SQUABBLE

ELIXIR - DEPLOYMENT - CONFIGURATION

ELIXIR - DEPLOYMENT - CONFORM

ELIXIR - DEPLOYMENT - CROSS-PLATFORM

ELIXIR - DEPLOYMENT - CROSS-PLATFORM - BAKEWARE
ELIXIR - DEPLOYMENT - CROSS-PLATFORM - BURRITO

ELIXIR - DEPLOYMENT - DISTILLERY (DEPRECATED)

ELIXIR - DEPLOYMENT - DOCKER

ELIXIR - DEPLOYMENT - EDELIVER

ELIXIR - DEPLOYMENT - ESCRIPTS

ELIXIR - DEPLOYMENT - EXRM (DEPRECATED)

ELIXIR - DEPLOYMENT - GATLING

ELIXIR - DEPLOYMENT - GITHUB ACTIONS

ELIXIR - DEPLOYMENT - HANDLE_CONTINUE

ELIXIR - DEPLOYMENT - KUBERNETES

ELIXIR - DEPLOYMENT - RELEASES

ELIXIR - DEPLOYMENT - START_PHASE

ELIXIR - DESKTOP

ELIXIR - DISTRIBUTION

ELIXIR - DISTRIBUTION - CONSENSUS ALGORITHMS

ELIXIR - DISTRIBUTION - CONSENSUS ALGORITHMS - GRAFT
ELIXIR - DISTRIBUTION - CONSENSUS ALGORITHMS - RA

ELIXIR - DISTRIBUTION - PARTISAN

ELIXIR - DISTRIBUTION - POGO

ELIXIR - EARMARK

ELIXIR - ECTO

ELIXIR - ECTO - 3.0

ELIXIR - ECTO - ASSOCIATIONS

ELIXIR - ECTO - COMPOSABLE QUERIES & NAMED BINDINGS

ELIXIR - ECTO - CUSTOM ECTO TYPES

ELIXIR - ECTO - EMBEDDED SCHEMAS

ELIXIR - ECTO - LIBRARIES

ELIXIR - ECTO - MIGRATIONS

ELIXIR - ECTO - MULTI

ELIXIR - ECTO - POSTGRESQL

ELIXIR - ECTO - POSTGRESQL - SCHEMAS

ELIXIR - ECTO - RELATIONS

  • Many to Many relationships in Ecto rawcode: Part 1 | Part 2

ELIXIR - ECTO - MYXQL

ELIXIR - ECTO - REPO.STREAM

ELIXIR - ECTO - SANDBOX

ELIXIR - ECTO - SQLITE3

ELIXIR - ECTO - SSL

ELIXIR - ECTO - UPSERTS

ELIXIR - EDITORS

ELIXIR - ELASTICSEARCH

ELIXIR - EMAIL

ELIXIR - ERROR HANDLING

ELIXIR - ETS

ELIXIR - EVENT SOURCING/CQRS

ELIXIR - EVENT SOURCING/CQRS - COMMANDED

ELIXIR - EVENT SOURCING/CQRS - SAGE

ELIXIR - EVENT SOURCING/CQRS - SEVEN OTTERS

ELIXIR - FUNCTIONAL PROGRAMMING

ELIXIR - GREMLEX

ELIXIR - GRAPHQL & ABSINTHE

ELIXIR - GRAPHQL & ABSINTHE - DATALOADER

ELIXIR - GUIS

ELIXIR - GUIS - RATATOUILLE

ELIXIR - GUIS - SCENIC

ELIXIR - HASHING

ELIXIR - HASTEGA

ELIXIR - HEX

ELIXIR - HEX - MINIREPO

ELIXIR - HTML PARSING

ELIXIR - IDES

ELIXIR - IEX

ELIXIR - JOBS

ELIXIR - JUPYTER NOTEBOOK

ELIXIR - KAFKA

ELIXIR - KHEPRI

ELIXIR - LIBGRAPH

ELIXIR - LIVEBOOK

ELIXIR - LIVEBOOK - ANIMATION

ELIXIR - LIVEBOOK - KINO

ELIXIR - LOGGING & MONITORING

ELIXIR - MACHINE LEARNING

ELIXIR - MACHINE LEARNING - EX_FAISS

ELIXIR - MACHINE LEARNING - NEURAL NETWORKS

ELIXIR - MACHINE LEARNING - NX

ELIXIR - MACHINE LEARNING - NX - AXON
ELIXIR - MACHINE LEARNING - NX - BUMBLEBEE
ELIXIR - MACHINE LEARNING - NX - EXPLORER
ELIXIR - MACHINE LEARNING - NX - SCHOLAR
ELIXIR - MACHINE LEARNING - NX - SCIDATA

ELIXIR - MACHINE LEARNING - PYTHON

ELIXIR - MACROS

ELIXIR - METAPROGRAMMING

ELIXIR - METRICS

ELIXIR - METRICS - PROMETHEUS

ELIXIR - MIX

ELIXIR - MNESIA

ELIXIR - MOEBIUS

ELIXIR - MUSIC

ELIXIR - NERVES

ELIXIR - NERVES - EXAMPLES

ELIXIR - NERVES - NERVES HUB

ELIXIR - NERVES - VINTAGE_NET

ELIXIR - NETWORKING

ELIXIR - NEWSLETTERS

ELIXIR - NIFS

ELIXIR - NIFS - RUST & RUSTLER

ELIXIR - NIFS - ZIGLER

ELIXIR - OBAN

ELIXIR - OBSERVABILITY

ELIXIR - OPUS

ELIXIR - OTP

ELIXIR - OTP - DYNAMIC SUPERVISORS

ELIXIR - PACKAGES

ELIXIR - PARSING

ELIXIR - PARSING - NIMBLE PARSEC

  • Nimble Parsec: Docs

ELIXIR - PERFORMANCE

ELIXIR - PERFORMANCE - BENCHEE

ELIXIR - PHOENIX

ELIXIR - PHOENIX - 1.7

ELIXIR - PHOENIX - 1.6

ELIXIR - PHOENIX - 1.5

ELIXIR - PHOENIX - 1.4

ELIXIR - PHOENIX - 1.3

ELIXIR - PHOENIX - ASSETS

ELIXIR - PHOENIX - AUTH/AUTH

ELIXIR - PHOENIX - CHANNELS

ELIXIR - PHOENIX - COMPONENTS

ELIXIR - PHOENIX - CONTEXTS

ELIXIR - PHOENIX - CONTROLLERS

ELIXIR - PHOENIX - DEPLOYMENT

Note: Elixir 1.9 includes release support:

Consequently, much of the following will soon be at least partially outdated:

ELIXIR - PHOENIX - DEVELOPMENT

ELIXIR - PHOENIX - EXAMPLE APPLICATIONS

ELIXIR - PHOENIX - JAVASCRIPT/TYPESCRIPT

ELIXIR - PHOENIX - JAVASCRIPT/TYPESCRIPT - TAILWIND CSS

ELIXIR - PHOENIX - JSON

ELIXIR - PHOENIX - LIVEBEATS

ELIXIR - PHOENIX - LIVE VIEW

ELIXIR - PHOENIX - LIVE VIEW - ALPINE.JS & SPRUCE
ELIXIR - PHOENIX - LIVE VIEW - ASSIGN_ASYNC
ELIXIR - PHOENIX - LIVE VIEW - JAVASCRIPT INTEROP
ELIXIR - PHOENIX - LIVE VIEW - LIVE COMPONENTS
ELIXIR - PHOENIX - LIVE VIEW - LIVE DASHBOARD
ELIXIR - PHOENIX - LIVE VIEW - LIVE MOTION
ELIXIR - PHOENIX - LIVE VIEW - LIVE SESSIONS
ELIXIR - PHOENIX - LIVE VIEW - LIVE STORYBOOK
ELIXIR - PHOENIX - LIVE VIEW - LIVE SVELTE

Live Svelte (Github) Live Svelte (HexDocs)

ELIXIR - PHOENIX - LIVE VIEW - SURFACE
ELIXIR - PHOENIX - LIVE VIEW - TESTING

ELIXIR - PHOENIX - LIVE VIEW NATIVE

ELIXIR - PHOENIX - MIX TASKS

ELIXIR - PHOENIX - PERFORMANCE

ELIXIR - PHOENIX - PHOENIX PRESENCE

ELIXIR - PHOENIX - PLUGS

ELIXIR - PHOENIX - PUB/SUB

ELIXIR - PHOENIX - TELEMETRY

ELIXIR - PHOENIX - TEMPLATES & LAYOUTS

ELIXIR - PHOENIX - TESTING

ELIXIR - PHOENIX - UPLOADS

ELIXIR - PHOENIX - VIDEOS

ELIXIR - PHOENIX - WEB SOCKETS

ELIXIR - PIGEON

ELIXIR - PODCASTS

ELIXIR - PORTS

ELIXIR - PORTS - PORCELAIN

  • Porcelain: Work with external processes like a boss: Github | Hexdocs

ELIXIR - PROCESSES

ELIXIR - PROJECTS

ELIXIR - PROTOCOLS

ELIXIR - PUB/SUB

ELIXIR - PULSAR

ELIXIR - PUSHEX

ELIXIR - RAXX (SIMPLE WEB SERVER)

ELIXIR - REDIS

ELIXIR - RIAK

ELIXIR - SECURITY

ELIXIR - SECURITY - CSP (CONTENT SECURITY POLICY)

ELIXIR - SECURITY - SOBELOW

ELIXIR - SSL

ELIXIR - STATE MACHINES

ELIXIR - STREAMS

ELIXIR - STRINGS

ELIXIR - TELEMETRY

ELIXIR - TESTING

ELIXIR - TESTING - ASYNCHRONOUS OTP

ELIXIR - TESTING - BYPASS

ELIXIR - TESTING - FLOW ASSERTIONS

ELIXIR - TESTING - HOUND

ELIXIR - TESTING - LOAD TESTING

ELIXIR - TESTING - MECKS UNIT

ELIXIR - TESTING - MOCK

ELIXIR - TESTING - MOCKERY

ELIXIR - TESTING - MOX

ELIXIR - TESTING - PROPERTY-BASED TESTING

ELIXIR - TESTING - PROPERTY-BASED TESTING - NORM

ELIXIR - TESTING - TYPECHECK

ELIXIR - TESTING - WALLABY

ELIXIR - TESTING - QUICKCHECK

ELIXIR - TOOLING

ELIXIR - TOOLING - KAFFY

ELIXIR - TYPES

ELIXIR - TYPES - DIALYZER/DIALYXIR

ELIXIR - TYPES - ELCHEMY

  • Elchemy: Write Elixir code using statically-typed Elm-like syntax (compatible with Elm tooling): Github
  • Elchemy book

ELIXIR - TYPES - TIME

ELIXIR - UMBRELLA PROJECTS

ELIXIR - VIDEOS

ELIXIR - WEB CRAWLING

ELIXIR - WEBRTC

ELIXIR - WEBRTC - MEMBRANE

ELIXIR - XML

ERLANG

ERLANG - GETTING STARTED

ERLANG - ACTOR MODEL

ERLANG - BEAM

ERLANG - BEAM - GARBAGE COLLECTION

ERLANG - BLOGS

ERLANG - CLIENTS

ERLANG - CLIENTS - HTTP CLIENTS

ERLANG - CODE QUALITY

ERLANG - CONCURRENCY

ERLANG - CONTRIBUTING

ERLANG - COWBOY

ERLANG - DEBUGGING

ERLANG - DEPLOYMENT

ERLANG - DEPLOYMENT - AWS

ERLANG - DISTRIBUTION

ERLANG - DOCUMENTATION

ERLANG - EBPF

ERLANG - ERLFMT

ERLANG - ERLPORT

ERLANG - ETS

ERLANG - EXAMPLES

ERLANG - FORGETS

ERLANG - HISTORY

ERLANG - LOGGING

ERLANG - LUMEN

ERLANG - MNESIA

ERLANG - MONITORING, METRICS & PERFORMANCE

ERLANG - MONITORING, METRICS & PERFORMANCE - AMOC

  • amoc (A Murder of Crows): simple framework for running massively parallel tests in a distributed environment: Github

ERLANG - MONITORING, METRICS & PERFORMANCE - DETECTER

ERLANG - MONITORING, METRICS & PERFORMANCE - FPROF

ERLANG - OBSERVER

ERLANG - OTP

ERLANG - OTP 23

ERLANG - OTP 22

ERLANG - OTP 21

ERLANG - PACKAGES

ERLANG - PACKAGES - POOLBOY

ERLANG - PACKAGES - RAM

  • Ram: in-memory distributed KV store for Erlang and Elixir, able to automatically manage dynamic clusters (addition / removal of nodes) and to recover from net splits - Roberto Ostinelli: Github | Documentation

ERLANG - PERSISTENT TERM

ERLANG - PODCASTS

ERLANG - PYRLANG

ERLANG - REBAR 3 (BUILD TOOL)

ERLANG - REGISTRIES

ERLANG - REGISTRIES - SYN

  • Syn: scalable global Process Registry and Process Group manager for Erlang and Elixir, able to automatically manage dynamic clusters (addition / removal of nodes) and to recover from net splits - Roberto Ostinelli: Documentation | Github

ERLANG - SHELL SCRIPTING

  • Erlang, the Unix way - "utilize Erlang's robust support for parallel computing in a project mostly comprised of Unix scripts. Let Erlang handle the chunk that can be parallelized, then hand it back to the calling script after it finishes"

ERLANG - SOCKET API

ERLANG - SSL

ERLANG - SUCCESS STORIES

ERLANG - TESTING

ERLANG - TESTING - LOAD TESTING

ERLANG - TESTING - LUX

ERLANG - TESTING - PROPERTY-BASED

ERLANG - TOOLS

ERLANG - TRACING

ERLANG - TRACING - EFLAME

ERLANG - TRACING - RECON

ERLANG - VIDEOS

ERLANG - XREF

ERLOG

  • Erlog: Prolog interpreter in and for Erlang: Github

GLEAM

GLEAM - ELIXIR

GLEAM - ERLANG

GLEAM - OTP

GLEAM - LIBRARIES

HAMLER

Kry10

"Operating System and Support Service built on the world-class seL4®, Erlang, and Elixir"

JOXA

LFE

LUERL

PURERL