def fib(n):
    if n < 0: raise Exception("No negative values !!!")
    if n == 0: return 0
    if n < 3: return 1
    return fib(n - 1) + fib(n - 2)

defmodule MyPoolPort do
  use Piton.Port
  def start(), do: MyPoolPort.start([path: Path.expand("python_folder"), python: "python"], [])
  def fun(pid, n), do: MyPoolPort.execute(pid, :functions, :fun, [n])
end

iex> {:ok, pool} = Piton.Pool.start_link([module: MyPoolPort, pool_number: 2], [])
{:ok, #PID<0.176.0>}

iex> Piton.Pool.execute(pool, :fib, [20])
6765

iex(test1@machine1)> MyProducer.start_link([], [name: {:global, :producer}]

iex(test2@machine2)> MyConsumer.start_link([producers_info: [{["topic"], {:global, :producer}}]], [name: {:global, :consumer}])

fun = fn(dependency_ref) -> MyDataModule.get(dependency_ref) end
{:ok, data} = Barenboim.get_data(dependency_ref, fun)

# Only the reference
Barenboim.notify({:reference, dependency_ref})

# Or the data
Barenboim.notify({:data, dependency_ref, dependency_data})

case Barenboim.get_data(dependency_ref, fun, 5_000) do
  {:ok, data} -> # go on
  {:timeout, any} -> # decide what you can do
end

test "receive message" do
  Process.register(self(), :main_process)
...

...
def handle_message(message) do
  result = do_work(message)
  send(:main_process, result)
  ...
end
...

# Main Process
...
Logger.info("Waiting for the message ...")
assert_receive(message, timeout)

# Main Process
...
receive do
  {topic, result} ->
    assert topic == expected_topic
    assert result == expected_result
  msg ->
    assert false
end

exports.config = {
  files: {
    javascripts: {
      joinTo: {
        "js/common.js": /(?!web\/static\/js\/specific)/,
        "js/myscript.js": /^(web\/static\/js\/specific\/one)/,
        "js/myscript2.js": /^(web\/static\/js\/specific\/two)/,
        "js/myscript3.js": /^(web\/static\/js\/specific\/three)/
      }
...
}

<script type="text/javascript" src="<%= static_path(@conn, "/your_app/js/common.js") %>"></script>
<script type="text/javascript" src="<%= static_path(@conn, "/your_app/js/" <> assigns[:js_script]) <> ".js" %>"></script>
<script>require("<%= "web/static/js/specific/" <> assigns[:js_script] <> "/" <> assigns[:js_script] %>")</script>

defmodule YourApp.YourController do
  use YourApp.Web, :controller

  def index(conn, _params) do
    conn
    |> assign(:js_script, "my_script")
    |> render("index.html")
  end

end

defmodule MyApplication.MyConsumer do
  use Conejo.Consumer

  def consume(_channel, _tag, _redelivered, payload) do
    IO.puts "Received  ->  #{inspect payload}"
  end
end

options = Application.get_all_env(:my_application)[:consumer] 

{:ok, consumer} = MyApplication.MyConsumer.start_link(options, [name: :consumer])

defmodule MyApplication.MyPublisher do
  use Conejo.Publisher

end

{:ok, publisher} = MyApplication.MyPublisher.start_link([], [name: :publisher])

#Synchronous
MyApplication.MyPublisher.sync_publish(:publisher, "my_exchange", "example", "Hola")

#Asynchronous
MyApplication.MyPublisher.async_publish(:publisher, "my_exchange", "example", "Adios")

config :my_application, :consumer,
 exchange: "my_exchange",
 exchange_type: "topic",
 queue_name: "my_queue",
 queue_declaration_options: [{:auto_delete, true}, {:exclusive, true}],
 queue_bind_options: [routing_key: "example"],
 consume_options: [no_ack: true]


config :conejo, 
 host: "my_host",
 port: 5672,
 username: "user",
 password: "pass"

# mix.exs
def deps do
   [{:conejo, git: "https://github.com/mendrugory/conejo.git"}]  # or [{:conejo, "~> 0.1.0"}] when is available
end

def application do
  [applications: [:conejo]]
end

object Problem2 {

  def main(args: Array[String]): Unit = {
    println("Project Euler 2\n")
    val number: Int = 4000000
    println("Mutability Result: \t" + time({mutable(number)}, "Mutability Time: \t"))
    println()
    println("Immutability Result: \t" + time({immutable(number)}, "Immutability Result: \t"))
  }

  def time[R](block: => R, introMessage:String): R = {
    val t0 = System.nanoTime()
    val result = block
    val t1 = System.nanoTime()
    println(introMessage + (t1 - t0) + "ns")
    result
  }

  def mutable(number: Int): Int = {
    var (first, second, acc) = (1, 2, 2)
    while (second < number) {
      val aux = second
      second += first
      first = aux
      if (second % 2 == 0)
        acc += second
    }
    acc
  }

  def immutable(number: Int): Int = {
    immutableFib(1, 2, number, 2)
  }

  def immutableFib(first: Int, second: Int, number: Int, acc: Int): Int = {
    second match {
      case _ if second < number =>
        val next = first + second
        val newAcc = if (next % 2 == 0) acc + next else acc
        immutableFib(second, next, number, newAcc)
      case _ => acc
    }
  }
}

Project Euler 2

Mutability Time:   1506573ns
Mutability Result:         4613732

Immutability Time:         25331ns
Immutability Result:       4613732

defmodule SubscriptionManager do

  def start_link do
    Agent.start_link(fn -> %{} end)
  end

  def start do
    Agent.start(fn -> %{} end)
  end

  def get_all(agent) do
    Agent.get(agent, fn x -> x end)
  end

  def get(agent, key) do
    Agent.get(agent, fn x -> Map.get(x, key) end)
  end

  def put(agent, key, value) do
    Agent.update(agent, fn x -> Map.put(x, key, value) end)
  end

  def delete(agent, key) do
    Agent.get_and_update(agent, fn x -> Map.pop(x, key) end)
  end

end

defmodule Publisher do
use GenServer

  # Server
  def start do
    {:ok, subscription_manager} = SubscriptionManager.start
    GenServer.start(Publisher, subscription_manager)
  end

  def handle_cast({:subscribe, name, pid}, subscription_manager) do
    SubscriptionManager.put(subscription_manager, name, pid)
    {:noreply, subscription_manager}
  end

  def handle_cast({:unsubscribe, name}, subscription_manager) do
    SubscriptionManager.delete(subscription_manager, name)
    {:noreply, subscription_manager}
  end

  def handle_cast({:notify, message}, subscription_manager) do
    SubscriptionManager.get_all(subscription_manager) |>
    Enum.map(fn {key, value} -> GenEvent.notify(value, message) end)
    {:noreply, subscription_manager}
  end

# Client
  def subscribe(server, name, pid) do
    GenServer.cast(server, {:subscribe, name, pid})
  end

  def unsubscribe(server, name) do
    GenServer.cast(server, {:unsubscribe, name})
  end

  def notify(server, message) do
     GenServer.cast(server, {:notify, message})
     IO.puts "I have published: '#{message}'"
  end

end

defmodule Subscriber do
use GenEvent

  def start do
    {:ok, pid} = GenEvent.start([])
    GenEvent.add_handler(pid, Subscriber, [])
    {:ok, pid}
  end

  def handle_event(message, state) do
    IO.puts "I have received: '#{message}'"
    {:ok, state}
  end
end

$ iex --sname node1 --cookie pubsub -S mix

iex(node1@host)> {:ok, manager} = Publisher.start
iex(node1@host)> :global.register_name('manager', manager)

iex --sname node2 --cookie pubsub -S mix

iex(node2@host)> Node.connect :'node1@host'
iex(node2@host)> manager = :global.whereis_name('manager')
iex(node2@host)> {:ok, subscriber} = Subscriber.start
iex(node2@host)> Publisher.subscribe(manager, 'subs_node2', subscriber)

iex --sname node3 --cookie pubsub -S mix

iex(node3@host)> Node.connect :'node1@host'
iex(node3@host)> manager = :global.whereis_name('manager')
iex(node3@host)> {:ok, subscriber} = Subscriber.start
iex(node3@host)> Publisher.subscribe(manager, 'subs_node3', subscriber)

iex> Publisher.notify(manager, "Hello !!")