josevalim

defmodule Api.Authorize do
  alias Account.Models.User

  def board?(board_id, %User{} = user, available_permissions, required_permissions) do
    with(
      {:ok, board} <- Tracker.Board.find(board_id),
      true <- Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id),
      ^required_permissions <-
        Enum.to_list(
          MapSet.intersection(

josevalim

Comparative Benchmark Numbers @ Rackspace

I've taken the benchmarks from Matthew Rothenberg's phoenix-showdown, updated Phoenix to 0.13.1 and ran the tests on the most powerful machines available at Rackspace.

Results

Framework	Throughput (req/s)	Latency (ms)	Consistency (σ ms)

josevalim

defmodule SomeModule do
  def start(host, options) do
    # We are assuming SomeSup has been already started somewhere
    # (ideally in a supervision tree).
    {:ok, child_pid} = SomeSup.attach_to(SomeSup, host, options)
  end
end

defmodule SomeSup do
  use Supervisor

josevalim

defmodule Exq.RouterPlug do
  import Plug.Conn
  use Plug.Router

  plug :match
  plug :dispatch

  get "/queues" do
    IO.puts "YOLO"
    conn |> halt()

josevalim

defmodule FibAgent do 
  def start_link do
    cache = Enum.into([{0, 0}, {1, 1}], HashDict.new)
    Agent.start_link(fn -> cache end)
  end
 
  def fib(pid, n) when n >= 0 do
    Agent.get_and_update(pid, &do_fib(&1, n))
  end
 

josevalim

% from my unit tests

foo = 10

assert 10 == my_macro(:foo)
assert 10 == my_macro("foo")

% macro

defmacro my_macro(some_var) when is_atom(some_var) do

josevalim

defmodule Dict.Behaviour do
  # It is assumed that the client module implements following functions:
  #
  #   size/1, fetch/2, put/3, reduce/3, update/4, delete/2
  #
  defmacro __using__(_) do
    quote do
      # Following are exact copies of HashDict:

      def get(dict, key, default // nil) do

josevalim

defmodule ExCoder do
  vars = [ { "	", "  " },
    { "!", "!" },
    { "" "", "\"" },
    { "#", "#" },
    { "$", "$" },
    { "%", "%" },
    { "& &", "&" },
    { "'", "'" },
    { "(", "(" },

josevalim

def next_state do
  (board, x, y) ->
    cell = cell_at(board, x, y)
    live_count = live_neighbors(board, x, y)
    next_state(cell, live_count)
  (_, x, y) when (x < 0 or y < 0) ->
    "."
end

def next_state do

josevalim

  def zip(a, b) do
    list = to_list(a)

    throw do
      { zipped, rest } = Reducers.reduce(b, { [], list }, fn
        entry, { acc, [h|t] } -> { [{entry, h}|acc], t }
        entry, { acc, [] } -> throw { :enum_zip, acc }
      end)

      :lists.foldl(fn(x, acc) ->