ndpar

-module(ring).

-export([start/3]).
-export([loop/1, loop/2]).


start(N, M, Message) when N > 1 -> spawn(fun() -> ring(N-1, M, Message) end).

ring(N, M, Message) when M > 0 ->
    P = lists:foldl(fun(_, Proc) -> spawn(fun() -> loop(Proc) end) end, self(), lists:seq(1, N)),

ndpar

-module(generic_server).

-export([start/0, loop/2]).
-export([request/1, change_state/1, change_function/1]).

%% Server

start() ->
    register(?MODULE, spawn(?MODULE, loop, [2, fun erlang:'+'/2])).

ndpar

class LazyList {

    private Closure list

    private LazyList(list) {
        this.list = list
    }

    static LazyList nil() {
        new LazyList( {-> []} )

ndpar

#!/usr/bin/env groovy

/**
 * Usage: ./SolrExporter.groovy query url [url]
 *
 * ./SolrExporter.groovy "id:12345" "http://your.solr.host:8983/solr/core/"
 * 
 * ./SolrExporter.groovy "id:12345" "http://old.solr.host:8983/solr/core/" "http://new.solr.host:8983/solr/core/"
 * 
 * 

ndpar

import urllib2
import zlib
import json
import pymongo
import sys

URL = 'http://api.stackoverflow.com/1.1'
ANSWERS = URL + '/questions/{0}/answers'

def load_url(url):

ndpar

#!/bin/sh

cd /opt/zookeeper/zookeeper
rm -rf cluster
mkdir -p cluster/server{1,2,3}/{conf,data,logs}

cp conf/log4j.properties cluster/server1/conf/
cp conf/log4j.properties cluster/server2/conf/
cp conf/log4j.properties cluster/server3/conf/

ndpar

; https://github.com/ndpar/clojure/blob/master/src/dojo/poker.clj
; https://github.com/ndpar/clojure/blob/master/test/dojo/poker_test.clj

(defn card-ranks
  "Return a vector of the ranks, sorted with higher first"
  [hand]
  (let [ranks (map #(->> % first str (.indexOf "--23456789TJQKA")) hand)
        ranks (vec (sort > ranks))]
    (if (= [14 5 4 3 2] ranks) [5 4 3 2 1] ranks)))

ndpar

#lang racket

;; Inspired by SICP, chapter 5.2.2, and
;; https://www.youtube.com/watch?v=SrKj4hYic5A

(define (rzip c1 c2)
  (let iter ([a c1] [z c2] [receive (λ (x y) y)])
    (if (null? a)
        (receive z '())
        (iter (cdr a) z

ndpar

(define-syntax-rule
  (redefine (f args ...) body ...)
  (set! f (λ (args ...) body ...)))

(define (double x)
  (+ x x))

(redefine (double x)
  (* 2 x))

ndpar

def Y = { f ->
  { x -> x(x) } { x -> f { y -> x(x)(y) } }
}

def triangular = Y { f ->
  { n -> n == 0 ? 0 : n + f(n - 1) }
}

triangular(3000)