Randy Lien randylien

Hello Friends,

This elf begging to climb onto the web for Christmas began as a personal email, a review of Paul Graham's little Lisp Bel. He sprouted arms, legs, and in gingerstyle ran away. Arms for symbols, legs for conses: these primitives are the mark a Lisp — even more so than the parenthesis. What do we get when we remove these foundation stones: naming and pairing?

No pairs. No cons. No structure. Unordered. Chaos. Eve, a beautifully incomplete aspect oriented triple store. No need for legs when you can effortlessly transport to your destination. Lazy. Pure. Here and now, a retrospective.

No symbols. No names. No variables. Combinators. Forth. No need for arms when you can effortlessly push and pop your stack. No words. A world without words. Virtual worlds. Virtual reality. Space. Time. Motion. Action. Kinetic Programming, a proposal.

I apologize in advance. Checking my pocketwatch, I see I haven't t

Git

Global Settings

Related Setup: https://gist.github.com/hofmannsven/6814278
Related Pro Tips: https://ochronus.com/git-tips-from-the-trenches/
Interactive Beginners Tutorial: http://try.github.io/
Git Cheatsheet by GitHub: https://services.github.com/on-demand/downloads/github-git-cheat-sheet/

Reminder

Press minus + shift + s and return to chop/fold long lines!

Comparing ES7 and core.async

ES7	core.async
`async function() {...}`	`(fn [] (go ...))`
`await ...`	`(<! ...)`
`await*` or `Promise.all(...)`	`(doseq [c ...] (<! c))`

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats. The link points back at them.

Why no pattern matching?

If you are talking about the aspect of pattern matching that acts as a conditional based upon structure, I'm not a big fan. I feel about them the way I do about switch statements - they're brittle and

	SPC
	SPC: find file
	, switch buffer
	. browse files
	: MX
	; EX
	< switch buffer
	` eval
	u universal arg
	x pop up scratch

	;;
	;; 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.

	(ns the-namespace.core
	(:require [clj-http.client :as client]
	[clojure.java.io :as io]))

	(defn- fetch-photo!
	"makes an HTTP request and fetches the binary object"
	[url]
	(let [req (client/get url {:as :byte-array :throw-exceptions false})]
	(if (= (:status req) 200)
	(:body req))))

	(ns clj-sleuth.crawl
	(:require [jsoup.soup :as c]
	[clojure.pprint :as p]
	[clojure.tools.logging :as log]))

	(Thread/setDefaultUncaughtExceptionHandler
	(reify Thread$UncaughtExceptionHandler
	(uncaughtException [_ thread ex]
	(log/error ex "Uncaught exception on" (.getName thread)))))

	# 0 is too far from ` ;)
	set -g base-index 1

	# Automatically set window title
	set-window-option -g automatic-rename on
	set-option -g set-titles on

	#set -g default-terminal screen-256color
	set -g status-keys vi
	set -g history-limit 10000