ExCampaignMonitor - a wrapper for Campaign Monitor's API

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: CloudSearch Structured Query Builder (1.0)

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.

mixpanel_api_ex has been updated to 1.0.1

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.

ElixirWeekly: The Elixir Community Newsletter, covering community news you easily miss, shared on ElixirStatus and the web, in one email every Thursday.

ESpec 1.6 is compatible with OTP 21

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

pre-push git hook: interactive format && credo

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

How we're combining Elixir and GraphQL at @Stuart_Delivery 🚀

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

Jenkins, Elixir, and ECS: CICD and Living on the Operational Edge

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

How to Contribute to Elixir: A Step-by-Step Guide

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

Phoenix the unofficial guide

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

Shameless plug: Check out @elixirstatus' other community project:

Credo, a new static code analysis tool that acts as a code linter, but also focusses on teaching coding practices and code consistency.

Decoupled Modules with Elixir EventBus

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

harnais_form v0.1.0

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 0.9.1 is out - with jQueryless Bootstrap Modal!

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

Phoenix PubSub

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

Understanding concurrency in Elixir

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

GraphQL Subscriptions - Connecting Phoenix Applications with Absinthe and WebSockets

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.

Practical Guide to Test Doubles in Elixir

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

Official release of Elixir: A Mini-Documentary!

🤙 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!

Wrapper for the fastest Elixir JSON encode/decode library

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

Bitcoin key derivation in Elixir

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

Maps vs Pattern Matching in Elixir

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