Graeme Coupar obmarg

ClojureScript macros: kinda, sorta, not really.

ClojureScript does not have a standalone macro system. To write ClojureScript macros, one must write them in Clojure and then refer to them in ClojureScript code. This situation is workable, but at a minimum it forces one to keep ClojureScript code and the macros it invokes in separate files. I miss the locality of regular Clojure macros, so I wrote something called maptemplate that gives me back some of what I miss. The technique may be useful in other scenarios.

Problem

Suppose you're wrapping functionality in another namespace or package so that you can have your own namespace of identically named but otherwise decorated functions:

ClojureScript:

Install

Either copy the aliases from the .gitconfig or run the commands in add-pr-alias.sh

Usage

Easily checkout local copies of pull requests from remotes:

git pr 4 - creates local branch pr/4 from the github upstream(if it exists) or origin remote and checks it out
git pr 4 someremote - creates local branch pr/4 from someremote remote and checks it out

A lot of these are outright stolen from Edward O'Campo-Gooding's list of questions. I really like his list.

I'm having some trouble paring this down to a manageable list of questions -- I realistically want to know all of these things before starting to work at a company, but it's a lot to ask all at once. My current game plan is to pick 6 before an interview and ask those.

I'd love comments and suggestions about any of these.

I've found questions like "do you have smart people? Can I learn a lot at your company?" to be basically totally useless -- everybody will say "yeah, definitely!" and it's hard to learn anything from them. So I'm trying to make all of these questions pretty concrete -- if a team doesn't have an issue tracker, they don't have an issue tracker.

I'm also mostly not asking about principles, but the way things are -- not "do you think code review is important?", but "Does all code get reviewed?".

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.

	(ns react-cljs.core
	(:require React))

	(declare render)

	(defn handle-change [e]
	(render {:text (.. e -target -value)}))

	(defn render [{:keys [text]}]
	(React/renderComponent

	;; This is at: https://gist.github.com/8655399

	;; So we want a rhyming dictionary in Clojure. Jack Rusher put up
	;; this code here:
	;;
	;; https://gist.github.com/jackrusher/8640437
	;;
	;; I'm going to study this code and learn as I go.
	;;
	;; First I put it in a namespace.

	;; ------------------------

	(defn- log-time [{:keys [ns name line]} f & args]
	(let [start (System/nanoTime)
	res (apply f args)
	elapsed (quot (- (System/nanoTime) start) 1000)]
	(log/debug (format "%s/%s:%s %dus" ns name line elapsed))
	res))

	(defn enable-timing [var]

	class WeakProperty:
	"""Descriptor that automatically holds onto whatever it contains as a weak
	reference. Reading this attribute will never raise `AttributeError`; if
	the reference is broken or missing, you'll just get `None`.

	The actual weak reference is stored in the object's `__dict__` under the
	given name, so this acts as sort of a transparent proxy that lets you
	forget you're dealing with weakrefs at all.

	Of course, if you try to assign a value that can't be weak referenced,

	(Chapters marked with * are already written. This gets reorganized constantly
	and 10 or so written chapters that I'm on the fence about aren't listed.)

	Programmer Epistemology
	* Dispersed Cost vs. Reduced Cost
	* Verificationist Fallacy
	* Mistake Metastasis
	The Overton Window
	Epicycles All The Way Down
	The Hyperspace Gates Were Just There