joshnuss

Example's Output

joshnuss

# $ elixir httpx.exs
# $ curl -v localhost:8080/test
defmodule HTTPX do
  defmodule Request,
    do: defstruct [:verb, :path, :query, :host, :headers]

  defmodule Response,
    do: defstruct [body: "", content_type: "text/plain", code: 200, headers: []]

  defmodule Server do

joshnuss

Parse & Generate Complex Query Strings

with Coffeescript

This code will allow you to build a JS dict/object from a query string. It supports arrays, dicts and scalars (strings)

For example, this string:

>> query = "arr[]=1&arr[]=2&q=foo&f=baz&h[a]=1&h[bc]=3"
>> queryString.parse(query)

joshnuss

# Parallel Checkout
# --------------------------------------------------------------
# Example of performance gained by using a parallel checkout in an e-commerce store,
#
# to run 500 checkouts in series: time elixir checkout.exs 500 serial
# to run 500 checkouts in parallel: time elixir checkout.exs 500 parallel
# 
# Typical E-commerce checkout flow uses a bunch of network bound tasks, that are generally
# computed synchronously. This wastes time and requires larger server clusters to handle peak times
# 

joshnuss

Infinite Scrolling with Angular.js

Use a simple directive to trigger reloading when nearing bottom of page.

Template

Example of triggering next page when user scroll 300px from bottom of page.

<section ng-controller='ContactsCtrl'>

joshnuss

// the main app file
import express from "express";
import loadDb from "./loadDb"; // dummy middleware to load db (sets request.db)
import authenticate from "./authentication"; // middleware for doing authentication
import permit from "./authorization"; // middleware for checking if user's role is permitted to make request

const app = express(),
      api = express.Router();

// first middleware will setup db connection

joshnuss

# Example of Elixir code consuming a Phoenix channel
#
# 1) Join a room
# 2) Send a message
# 3) Receive a message
#
# Add `socket` to your deps in `mix.exs`
# {:socket, "~> 0.3"}
#
# To run:

joshnuss

defmodule Stack do
  use GenServer

  @name __MODULE__

  def start_link,
    do: GenServer.start_link(__MODULE__, [], name: @name)
    
  def pop,
    do: GenServer.call(@name, :pop)

joshnuss

Distributed RAID1

This is an example of adding redundancy and reliability to a storage system using Elixir.

The uptime of a system can be increased by storing the data redundantly across multiple nodes. If a node goes down, the entire system isn't effected, as long as one of the nodes remains up - the system will continue to function.

It's pretty easy to accomplish this with a GenServer, instead of using GenServer.call/3, use GenServer.multi_call/4. With multi_call, a call is sent to each node in parallel. It's an easy way to implement redundant writes, similar to RAID1.

How it works

joshnuss

defmodule Line do
  def slope({x1, y1}, {x2, y2}),
    do: delta(y1, y2) / delta(x1, x2)

  def intercept(point: {x, y}, slope: slope),
    do: {0, y - (slope * x)}

  def point(x: x, slope: slope, intercept: intercept),
    do: {x, (slope * x) + intercept}