tomconnors

;; There are some patterns with c.a.flow that weren't immediately obvious to me so I made this gist to
;; figure them out.
;; Those patterns are:
;; - backpressure across processes
;; - long-running tasks
;; - getting inputs for the first process in the flow

(require '[clojure.core.async :as async]
         '[clojure.core.async.flow :as flow]
         '[clojure.pprint :as pp]

irwansyahwii

statement -> element_expr:*  {% id %}
	| null {% id %}

element_expr -> actor_expr {% id %}
	| boundary_expr  {% id %}
	| call_expr {% id %}
	| participant_expr {% id %}

jonico

#!groovy
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

def label = "mypod-${UUID.randomUUID().toString()}"
podTemplate(label: label, yaml: """
spec:
      containers:
      - name: mvn
        image: maven:3.3.9-jdk-8

kennyjwilli

(defmacro defspec-test
  ([name sym-or-syms] `(defspec-test ~name ~sym-or-syms nil))
  ([name sym-or-syms opts]
   (when t/*load-tests*
     `(def ~(vary-meta name assoc :test `(fn []
                                           (let [check-results# (clojure.spec.test/check ~sym-or-syms ~opts)
                                                 checks-passed?# (every? nil? (map :failure check-results#))]
                                             (if checks-passed?#
                                               (t/do-report {:type    :pass
                                                             :message (str "Generative tests pass for "

Avaq

const I  = x => x
const K  = x => y => x
const A  = f => x => f (x)
const T  = x => f => f (x)
const W  = f => x => f (x) (x)
const C  = f => y => x => f (x) (y)
const B  = f => g => x => f (g (x))
const S  = f => g => x => f (x) (g (x))
const S_ = f => g => x => f (g (x)) (x)
const S2 = f => g => h => x => f (g (x)) (h (x))

kilfu0701

## in command line
whereis xar
# > /usr/bin/xar

xar --version
# > xar 1.7dev

## check if there's '--extract-cert' option ?
xar -h

divarvel

console.log("\033[39mRunning tests…");
function assertEquals(actual, expected, description) {
    if(typeof actual === "undefined") {
        console.error("\033[31m" + description + " not implemented\033[39m");
    } else {
        if(actual !== expected) {
            console.error("\033[31m" + description + " failed, expected " + expected + ", got " + actual + "\033[39m");
        } else {
            console.log(description + " \033[32m ok\033[39m");
        }

john2x

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

adam3smith

TY  - JOUR
TI  - Unions, Norms, and the Rise in U.S. Wage Inequality
AU  - Western, Bruce
AU  - Rosenfeld, Jake
T2  - American Sociological Review
AB  - From 1973 to 2007, private sector union membership in the United States declined from 34 to 8 percent for men and from 16 to 6 percent for women. During this period, inequality in hourly wages increased by over 40 percent. We report a decomposition, relating rising inequality to the union wage distribution’s shrinking weight. We argue that unions helped institutionalize norms of equity, reducing the dispersion of nonunion wages in highly unionized regions and industries. Accounting for unions’ effect on union and nonunion wages suggests that the decline of organized labor explains a fifth to a third of the growth in inequality—an effect comparable to the growing stratification of wages by education.
DA  - 2011///
PY  - 2011
DO  - 10.1177/0003122411414817
DP  - Highwire 2.0