JamesDullaghan

Deploy Rails app to digitalocean with nginx, unicorn, capistrano & postgres

Create droplet of your liking (ubuntu 12.10 x32)

ssh to root in terminal with your server ip

ssh root@123.123.123.123

Add ssh fingerprint and enter password provided in email

bitemyapp

The Learning Haskell guide has been moved to a git repo to enable outside contribution

Find it here: https://github.com/bitemyapp/learnhaskell

Integralist

Designing Systems and Applications

This is a short document of tips and notes I've accumulated while learning more about designing distributed systems and building concurrent applications. It is by no means definitive and merely scratches the surface of what is needed to be considered when designing an architecture expected to handle large scale traffic.

Distributed Systems

Scale out, not up

There reaches a point in your application's design where by merely throwing more hardware at the problem (i.e. "scaling up") will fail to resolve the scalability issues you're encountering.

vmarquez

    //Reader Monad and its extension class to give it SelectMany(bind/flatMap) capabilities for use in LINQ queries
    public static class ReaderMonadExt
    {
        public static ReaderMonad<T, C> SelectMany<T, A, B, C>(this ReaderMonad<T, A> rm, Func<A, ReaderMonad<T, B>> bindf, Func<A, B, C> select)
        {
            return new ReaderMonad<T, C>(t =>
            {
                var a = rm.Run(t);
                return select(a, bindf(a).Run(t));
            });

hyone

{-# LANGUAGE FlexibleContexts #-}

import Data.Conduit
import qualified Data.Conduit.List as CL
import Network.HTTP.Conduit

import Control.Concurrent.Async (mapConcurrently)
import Control.Concurrent.MVar
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Trans.Control (MonadBaseControl)

sw17ch

> module Main where

First, import all the needed modules.

> import Text.Parsec hiding (State)
> import Text.Parsec.Indent
> import Control.Monad.State

Next, define our new Parser type. This replaces the Identity monad
with the (State SourcePos) monad.

lrvick

 app.controller( 'AppCtrl', function ($scope, socket) {
    socket.onopen(
        function(){
            console.log('Socket is connected :D')
        }
    )
    socket.onclose(
        function(){
            console.log('Socket is disconnected :(')
        }

koddo

;; for Coursera / Programming Languages
;; in emacs sml-mode: single keystroke for restarting repl and loading current file
(require 'cl)
(add-hook 'sml-mode-hook
          (lambda ()
            (define-key sml-mode-map (kbd "C-c C-v") 'my-sml-restart-repl-and-load-current-file)
            (defun my-sml-restart-repl-and-load-current-file ()
              (interactive)
              (ignore-errors (with-current-buffer "*sml*"
                               (comint-interrupt-subjob)

richhickey

(defmacro test->
  "Takes an expression and a set of test/form pairs. Threads expr (via ->)
  through each form for which the corresponding test expression (not threaded) is true."
  [expr
  & clauses]
  (assert (even? (count clauses)))
  (let [g (gensym)
        pstep (fn [[test step]] `(if ~test (-> ~g ~step) ~g))]
    `(let [~g ~expr
           ~@(interleave (repeat g) (map pstep (partition 2 clauses)))]

ztellman

(ns dojo.core
  (:require
    [clojure.string :as str]))

;;;

(def digits
  [[" _ " "| |" "|_|"]
   ["   " "  |" "  |"]
   [" _ " " _|" "|_ "]