Package’s dependencies have been updated to latest versions. Release introduces new configuration option: active. When active == false it will not call remote API (useful for testing): config :mixpanel_api_ex, token: “<Put API token here>”, active: true.

Link to the package at hex.pm.

As you might know, tuple call support was removed in OTP 21, so Ruby-like syntax expect(smth).to eq(smth_else) won’t work.

Version 1.6.0 allows you run ESpec with the new Erlang, but it doesn’t remove the old syntax completely, so you still can use it with older versions of OTP. But I recommend you to rewrite your tests using “pipe syntax”.

More details are here: https://github.com/antonmi/espec

A pre_push hook which …

• checks if your files are formatted (mix format –check-formatted)
• if not, prompts you if you want to format them now
• prompts if you want to run credo
• prompts you if you want to abort the push if any of the previous steps failed

https://gist.github.com/Zeeker/c63ba089fd732a359e64d7a556964d8b

GraphQL with a Functional Backend: https://medium.com/stuart-engineering/graphql-with-a-functional-backend-a162b3e387a2

CI/CD on AWS ECS on Jenkins https://engineering.tripping.com/jenkins-elixir-and-ecs-cicd-and-living-on-the-operational-edge-f24f569aea74

http://www.sihui.io/how-to-contribute-to-elixir/

guide for everything that contains third parties services (deployments, continuous integrations…) since it can’t make it into the official doc Currently

• docker deployment on a single machine
• continuous integration/deployment

https://github.com/happysalada/phoenix-the-unoffcial-guide

Elixir EventBus is a library that allows different modules to communicate with each other without knowing about each other. A module/function can create an Event struct, and deliver to the EventBus without knowing which modules will consume.

https://medium.com/elixirlabs/decoupled-modules-with-elixir-eventbus-a709b1479411

Just pushed to Hex the first cut of harnais_form.

If you do a lot of metaprogramming, you might find this package a help when testing.

Drab.Modal.alert does not require jQuery anymore! You may ask user anything, from the server side, and synchronously wait for the answer.

https://github.com/grych/drab/releases/tag/v0.9.1

Using Phoenix.PubSub to send messages across processes https://www.pompecki.com/post/phoenix-pubsub/

https://www.jackmarchant.com/articles/understanding-concurrency-in-elixir

We (Annkissam) just released two GraphQL-related packages CommonGraphQLClient and AbsintheWebSocket. We also created a walkthrough describing how they can be used to connect Phoenix Applications with Absinthe and WebSockets.

Draw a clear line between fakes, stubs, mocks, and spies in Elixir, and learn how to use them.

https://semaphoreci.com/community/tutorials/practical-guide-to-test-doubles-in-elixir

🤙 Calling all #elixir & #erlang enthusiasts!

Honeypot’s “ELIXIR: A MINI-DOCUMENTARY”, featuring José Valim, creator of Elixir, Chris McCord, creator of the Phoenix Framework, Justin Schneck, co-author of the Nerves project, & other members of the Elixir community, has just been released!

A wrapper for the fastest Elixir JSON encode/decode library (:jiffy) with atomized keys

defmodule JSON do
  @moduledoc false

  @encode_opts [:use_nil]
  @decode_opts [:return_maps, :use_nil]

  alias :jiffy, as: Jiffy

  @doc """
  Encode and return tuple
  """
  @spec encode(any) :: {:ok, Strint.t()} | {:error, tuple()}
  def encode(nil) do
    {:ok, nil}
  end

  def encode(payload) do
    {:ok, Jiffy.encode(payload, @encode_opts)}
  catch
    {:error, reason} -> {:error, reason}
  end

  @doc """
  Encode and return encoded json
  """
  @spec encode!(any) :: Strint.t() | {:error, tuple()}
  def encode!(payload) do
    case encode(payload) do
      {:ok, json} -> json
      {:error, reason} -> {:error, reason}
    end
  end

  @doc """
  Decode and return tuple
  """
  @spec decode(String.t() | nil) :: {:ok, Map.t() | list()} | {:error, tuple()}
  def decode(payload) do
    {:ok, Jiffy.decode("#{payload}", @decode_opts)}
  catch
    {:error, reason} -> {:error, reason}
  end

  @doc """
  Decode and return decoded data
  """
  @spec decode!(String.t() | nil) :: Map.t() | list() | {:error, tuple()}
  def decode!(payload) do
    case decode(payload) do
      {:ok, data} -> data
      {:error, reason} -> {:error, reason}
    end
  end

  @doc """
  Convert map string keys to atom keys
  This function is an optional to atomize map keys instead of having
  string keys. 
  Warning: By default, the maximum number of atoms is 1,048,576.
           This function should be used responsibly. Personally,
           I recommend to use this function if you only can validate
           the JSON schemas.
  """
  @spec atomize_keys(any()) :: any()
  # Walk through the map
  def atomize_keys(map = %{}) do
    map
    |> Enum.map(fn {k, v} -> {to_atom(k), atomize_keys(v)} end)
    |> Enum.into(%{})
  end

  # Walk through the list
  def atomize_keys([head | rest]) do
    [atomize_keys(head) | atomize_keys(rest)]
  end

  # Other data types
  def atomize_keys(other) do
    other
  end

  defp to_atom(key) when is_atom(key) do
    key
  end

  defp to_atom(key) when is_binary(key) do
    String.to_atom(key)
  end

  defp to_atom(key) do
    key
  end
end

The ultimate guide to deriving child keys in Bitcoin wallet using Elixir​: https://k.lelonek.me/bitcoin-key-derivation

For some purposes, it is possible to use pattern matching instead of using a map to perform lookups.

This is my exploration of this, with some benchmarking, mystery and an unexpected plot twist!

https://medium.com/@amuino/maps-vs-pattern-matching-in-elixir-e69b7bb11b5d

The project we’re building is going to be an application that will store/retrieve Event Logs. You could use this for something like tracking requests you’re making, or tracking audit events in a log, or…well, anything that would require storing some arbitrary events with types, messages, and payloads.

How to use private hex dependencies in your docker images while building your releases https://engineering.tripping.com/how-to-use-private-hex-dependencies-in-your-docker-images-42b2d01d8d70 #myelixirstatus