Alan alanmarazzi

Quick Tips for Fast Code on the JVM

I was talking to a coworker recently about general techniques that almost always form the core of any effort to write very fast, down-to-the-metal hot path code on the JVM, and they pointed out that there really isn't a particularly good place to go for this information. It occurred to me that, really, I had more or less picked up all of it by word of mouth and experience, and there just aren't any good reference sources on the topic. So… here's my word of mouth.

This is by no means a comprehensive gist. It's also important to understand that the techniques that I outline in here are not 100% absolute either. Performance on the JVM is an incredibly complicated subject, and while there are rules that almost always hold true, the "almost" remains very salient. Also, for many or even most applications, there will be other techniques that I'm not mentioning which will have a greater impact. JMH, Java Flight Recorder, and a good profiler are your very best friend! Mea

How Clojure's documentation can leapfrog other languages

Summary

I made a documentation generator that cashes in on Clojure's dynamism. See the play-cljs docs (a ClojureScript game library) for an example of its output.

The Problem

Like many of you, I've often wondered what my final regret will be on my deathbed. My best guess came to me in a dream recently. I was walking across the charred earth of an apocalyptic future world, maneuvering around the remains of the less fortunate. I was startled to find a young girl, barely holding onto her life. She murmured something to me. I asked her to repeat it, and she said more loudly: "I...wish your Clojure projects didn't have such crappy documentation."

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.

	(ns defwrapper
	(:require [clojure.string :as str]))

	(set! warn-on-reflection true)

	(defn class-methods [^Class class]
	(seq (.getMethods class)))

	(defn constructors [^Class klazz]
	(.getDeclaredConstructors klazz))

	# Clone the Tensorflow Serving source
	git clone https://github.com/tensorflow/serving
	cd serving && git checkout <commit_hash>

	# Build the docker image (time to go get yourself a coffee, maybe a meal as well, this will take a while.)
	docker build -t some_user_namespace/tensorflow-serving:latest -f ./serving/tensorflow_serving/tools/docker/Dockerfile.devel .

	# Run up the Docker container in terminal
	docker run -ti some_user_namespace/tensorflow-serving:latest


	mkdir -p /work/

	# Clone the source from Github
	cd /work/ && git clone — recurse-submodules https://github.com/tensorflow/serving

	# Pin the version of Tensorflow Serving and its submodule
	TENSOR_SERVING_COMMIT_HASH=85db9d3
	TENSORFLOW_COMMIT_HASH=dbe5e17
	cd /work/serving && git checkout $TENSOR_SERVING_COMMIT_HASH

	(defn- sanitize-key
	[k]
	(s/replace (name k) "-" "_"))

	(defn- sanitize-val
	[v]
	(cond
	(keyword? v) (sanitize-val (name v))
	(string? v) (format "\"%s\"" v)
	:else v))

	(require '[clojure.core.async :as async]
	'[clj-http.client :as client]
	'[clojure.data.json :as json])

	(def concurrency 5)

	(let [in (async/chan)
	out (async/chan)
	request-handler (fn [url out*]
	(async/go

	(ns sql-like-join
	(:require [clojure.set :refer [difference
	intersection
	union]]))

	(defn inner-join
	[left-keys right-keys]
	(intersection (set left-keys) (set right-keys)))

	(defn outer-join