I wanted to use campaign monitor but nothing was available in Elixir - so I created this one: https://hex.pm/packages/ex_campaign_monitor

CSQuery is a query builder for the AWS CloudSearch structured search syntax. This query builder is largely inspired by csquery for Python.

Version 1.0 has been released and can be found on GitHub.

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