shripadk

###
Module dependencies
###
require.paths.unshift "#{__dirname}/lib/support/express-csrf/"
require.paths.unshift "#{__dirname}/lib/support/node_hash/lib/"

express 	= require 'express'
app 		= module.exports = express.createServer()

RedisStore 	= require 'connect-redis'

also

function Nest(api_key) {
    this.api_key = api_key;
}

Nest.prototype = {
    analyzeFile: function(file, type, options) {
        var form = new FormData();
        form.append('api_key', this.api_key);
        form.append('track', file);
        form.append('filetype', type);

tekacs

# Usage: show <local-port> <subdomain>
function show() {
    DOMAIN=".tekacs.com"
    REMOTE="$2$DOMAIN"
    ssh -tR 1080:127.0.0.1:$1 vps "sudo ssh -Nl \$USER -L $REMOTE:80:127.0.0.1:1080 localhost"
}

kellymclaughlin

KV Operations

The following list illustrates how the Riak KV operations would be specified using different apis. The first sub-entry for each list member represents how the operation is specified in the existing api. The second sub-entry shows the operation in the new proposed api and the final sub-entry uses a shortened syntax of b for buckets and k for keys.

1. List Buckets

josephg

# A synchronous processing queue. The queue calls process on the arguments,
# ensuring that process() is only executing once at a time.
#
# process(data, callback) _MUST_ eventually call its callback.
#
# Example:
#
# queue = require 'syncqueue'
#
# fn = queue (data, callback) ->

pingles

(defn bytes-to-int
  ([bytes]
     (bytes-to-int bytes 0))
  ([bytes offset]
     (reduce + 0
             (map (fn [i]
                    (let [shift (* (- 4 1 i)
                                   8)]
                      (bit-shift-left (bit-and (nth bytes (+ i offset))
                                               0x000000FF)

amtal

-module(rpn).
-export([eval/1, hypotenuse/2]).
-compile({parse_transform,do}).

-spec eval([Op]) -> stack_m(ok).
%% Interpreter for a simple stack-based language.
%%
%% Uses a custom stack_m monad, which is a trivial wrapper around state_m[1].
%% It exports:
%%  -spec pop() -> stack_m(A).

gfredericks

(def *config* nil)

(defn wrap-configged-fn
  [f]
  (fn [& [maybe-config :as args]]
    (if (and *config* (not (identical? *config* maybe-config)))
      (apply f *config* args)
      (apply f args))))

(defmacro defn-with-config

AlexBaranosky

;; This first swipe at generative-style testing in Midje was super easy:

;; first a use of it

(defn make-string []
  (rand-nth ["a" "b" "c" "d" "e" "f" "g" "i"]))

(formula [a (make-string) b (make-string)]
  (str a b) => #(.startsWith % a))

Pet3ris

(ns fsm
  (:refer-clojure :exclude [==])
  (:use [clojure.core.logic]))

;; Encoding a Finite State Machine and recognizing strings in its language in Clojure core.logic

;; We will encode the following FSM:
;;
;;  (ok) --+---b---> (fail) 
;;   ^     |