Roger Jungemann rjungemann

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.

How to use:

The link in the table of content jumps at the copy of the answer on this page.
The link on the answer itself points back at the original post.

Table of Content

Cloudbleed: Users can't fix themselves

TL;DR

Site-owners MUST invalidate all their users sessions and tokens now, and might want to consider doing so again in the not distant future.

Cloudflare domain lists

There has been a great deal of discussion about the Cloudflare domain lists that are being constructed. These lists are not really all that useful for cleaning up this mess. Let me explain.

This guide has moved

To improve collaboration this guide is now available on GitHub.

Continue reading

repl time

$ boot repl

boot.user=> (require :reload '[pipeline :refer [engine]]
                             '[mount.core :as mount])
"|| mounting... #'pipeline/engine"

starting it

Racket `#lang`s and the REPL

The Racket platform provides a robust set of tools for developing languages, mostly centered around the macro system and the #lang protocol, which allows providing arbitrary readers to convert text input to syntax objects representing Racket modules. The REPL is a bit more complicated, however, because it has different rules—each expression needs to be dynamically read, assigned lexical context, expanded, compiled, evaluated, and printed, all in real time. (In that sense, perhaps the phrase “REPL” oversimplifies what Racket is doing, but that’s a separate conversation.)

So how does Racket accommodate this in the face of completely arbitrary user-defined languages, some of which may not even support interactive evaluation in a traditional sense? Racket mostly solves this problem by having a related but distinct set of protocols for managing runtime interactions that operates alongside #lang.

Modules and the top level

Racket’s evaluation model divides pretty much ev

	#!/usr/bin/env bash

	# fanout utility - send stdin input to multiple target commands.
	#
	# Copyright (c) 2017 Michael Klement, released under the [MIT license](http://opensource.org/licenses/MIT).
	#
	# Aside from requiring Bash 3+, this utility should be portable:
	# It uses only POSIX-compliant utilities with POSIX-compliant options.
	#
	# Invoke with --help for help.

	(module
	(func $addTwo (param i32 i32) (result i32)
	(i32.add
	(get_local 0)
	(get_local 1)))
	(export "addTwo" (func $addTwo)))

	<div id="app">
	{{ message }}
	<button v-on:click="increment">+</button>
	<button v-on:click="decrement">-</button>
	</div>

	Retraining (ie https://www.tensorflow.org/versions/r0.11/how_tos/image_retraining/index.html ) doesnt really go into
	nuances about what types of labels you should choose based on your model.

	Since InceptionV3 is an object recognition task, and the penultimate layer (pool 3) contains some 2048 vector length descriptions that
	somehow infer various 'objectness' traits, its far better to say:

	train for labels that tend toward objectness (lamp, lampshade, chandelier, standing lamp, desk lamp)
	than train for labels that then to abstract image features like composition: chaotic, patterned, symmetric, asymmetric, mirrored, circular, diagonal, natural (photographic) , synthetic)

	If I were interested in the latter labeling (ie, meta-features), is it more sensible to:

	(*
	Some time ago I found this tutorial about writing a small VM in c.
	http://blog.felixangell.com/blog/virtual-machine-in-c
	Here's something similar in OCaml. Nothing super fancy and a lot of room for improvements.
	But it's a start :)
	*)
	open Core.Std

	type registers = {
	mutable a: int;