ghoseb

;;
;; NS CHEATSHEET
;;
;; * :require makes functions available with a namespace prefix
;;  and optionally can refer functions to the current ns.
;;
;; * :import refers Java classes to the current namespace.
;;
;; * :refer-clojure affects availability of built-in (clojure.core)
;;   functions.

didip

[unix_http_server]
file=/tmp/supervisor.sock                       ; path to your socket file

[supervisord]
logfile=/var/log/supervisord/supervisord.log    ; supervisord log file
logfile_maxbytes=50MB                           ; maximum size of logfile before rotation
logfile_backups=10                              ; number of backed up logfiles
loglevel=error                                  ; info, debug, warn, trace
pidfile=/var/run/supervisord.pid                ; pidfile location
nodaemon=false                                  ; run supervisord as a daemon

jacqui

# Optimized for writes, sort on read

# LVC
redis.hset("bonds|1", "bid_price", 96.01)
redis.hset("bonds|1", "ask_price", 97.53)
redis.hset("bonds|2", "bid_price", 95.50)
redis.hset("bonds|2", "ask_price", 98.25)
redis.sadd("bond_ids", 1)
redis.sadd("bond_ids", 2)

daveray

; A REPL-based, annotated Seesaw tutorial
; Please visit https://github.com/daveray/seesaw for more info
;
; This is a very basic intro to Seesaw, a Clojure UI toolkit. It covers
; Seesaw's basic features and philosophy, but only scratches the surface
; of what's available. It only assumes knowledge of Clojure. No Swing or
; Java experience is needed.
;
; This material was first presented in a talk at @CraftsmanGuild in
; Ann Arbor, MI.

Jaskirat

(defn insert [l k]
"Function to do insert in sorted order"
      (concat (filter #(< % k) l)  [k] (filter #(> % k) l)))

(defn isort [l]
"Insertion sort"
      (loop [r []
             l  l]
         (if (empty? l)
             r

swannodette

(ns puzzle
  (:refer-clojure :exclude [==])
  (:use [clojure.core.logic])
  (:require [clojure.core.logic.set :as set]))

(defn existso [q ps] (fresh [x] (featurec x ps) (membero x q)))
(defn ruleo [q p v tp tv] (existso q {p v tp tv}))
(defn neg-ruleo [q p v tp tv] (fresh [x] (!= x tv)) (existso q {p v tp x}))

(defn earliero [q p v op ov]

quchen

13:15 <xQuasar>      | HASKELL IS FOR FUCKIN FAGGOTS. YOU'RE ALL A BUNCH OF 
                     | FUCKIN PUSSIES
13:15 <xQuasar>      | JAVASCRIPT FOR LIFE FAGS
13:16 <luite>        | hello
13:16 <ChongLi>      | somebody has a mental illness!
13:16 <merijn>       | Wow...I suddenly see the error of my ways and feel 
                     | compelled to write Node.js!
13:16 <genisage>     | hi
13:16 <luite>        | you might be pleased to learn that you can compile 
                     | haskell to javascript now

mplewis

Flask + uWSGI + nginx Primer

I've been having trouble with serving a Flask app via uWSGI and nginx, so I thought I'd put together some of the basics to help out others.

How this shit works

• Flask is managed by uWSGI.
• uWSGI talks to nginx.

simonista

" Don't try to be vi compatible
set nocompatible

" Helps force plugins to load correctly when it is turned back on below
filetype off

" TODO: Load plugins here (pathogen or vundle)

" Turn on syntax highlighting
syntax on

hiredman

#!/usr/bin/java -jar clojure-1.7.0-master-SNAPSHOT.jar    

(let [pom-uber-jar                                                                                                                                                      
      (str "http://thelibraryofcongress.s3.amazonaws.com/"                                                                                                              
           "pomegranate-0.0.13-SNAPSHOT-jar-with-dependencies.jar")                                                                                                     
      cl (java.net.URLClassLoader. (into-array [(java.net.URL. pom-uber-jar)]))                                                                                         
      cx (.getContextClassLoader (Thread/currentThread))]                                                                                                               
  (push-thread-bindings {clojure.lang.Compiler/LOADER cl})