Alan Dipert alandipert

Local Async Pull Request Workflow with Codex + git-appraise

Problem

Most code review systems (GitHub, GitLab, etc.) depend on hosted web services.
They’re slow, require accounts and internet access, and scatter review metadata outside the repo.
For solo work, private code, or AI collaboration, that’s unnecessary friction.

Constraints

An Upper Bound on the Probability of a Macroscopic Food Object (a “Kraft Single”) Arising as a Boltzmann Fluctuation

Abstract

We bound the probability that thermal fluctuations in the observable universe have ever produced, for any nonzero duration, a specific macroscopic object: a ~20 g processed cheese slice (“Kraft Single”). Modeling the event as a large negative entropy fluctuation out of near-equilibrium matter, we combine (i) a conservative lower bound on the entropy decrease required for coarse localization of ~10²⁴ atoms into a fixed 10⁻⁵ m³ volume with (ii) an extremely generous upper bound on the total number of statistically independent spacetime trials (Planck-scale 4-cells across the observable universe and its age). The resulting expectation ( \mathbb E[N] ) and total probability (P) obey

[ \mathbb E[N];\lesssim;P;\lesssim;10^{-4.34\times 10^{24}}, ]

i.e., effectively zero for any physical purpose. Tighter (more realistic) modeling only decreases (P).

Identity, Dipert, and LLMs: Structured Comparison

Classical Ontological Options
- Substratum (Substance) Theory: Objects are "bare particulars" which have attributes, but the identity of the object is independent of the attributes.
- Bundle Theory: Objects are nothing over and above their attributes; what individuates an object is the collection of its properties.
- Problems: Substrata are metaphysically mysterious; bundles have difficulty with individuation, especially when two objects share all attributes.
Dipert's Graph-Based Structural Ontology
- Randall R. Dipert in "The Mathematical Structure of the World: The World as Graph" argues that the world is a single, large graph.
  (https://philpapers.org/rec/DIPTMS?utm_source=chatgpt.com)

The following was sent to the JACL e-mail announcement list on 2021-02-26.

Hello everyone, and a belated happy 2021 to you! I hope your year has been off to a good start.

It's been almost a year since JACL became public, and nearly as long since any other announcement or release, so I thought to share three major related educational and design developments. The project is very much alive, just mostly in my head :-)

First, while I haven't made significant tangible progress on the JACL compiler or runtime since last year, I have continued to research and study implementation techniques. I have prototyped several schemes for efficient and JavaScript-friendly multiple-value returns, consuming relevant literature (mostly from the Scheme community) along the way. I have also studied and experimented with CLOS, and to speculate about how best to support a maximum of CLOS functionality without compromising JACL's calculated relationship with the JavaScript platform. One interes

	(defun find-terms (num-terms max-size
	&optional (desired-sum 0)
	&aux (iterations 0))
	"Returns a list of terms in the range -max-size ... +max-size,
	inclusive, that sum to desired-sum.

	Has strange properties. Likelier to blow the stack as max-size
	increases. Seems to spend most time backtracking on the last few
	terms.

	(defconstant mv-limit 20)

	(defparameter mv-expected 1)

	(defparameter mv (make-array mv-limit))

	(defun mv (&rest vals)
	(do ((i 0 (1+ i))
	(vs vals (cdr vs)))
	((or (eql i mv-expected) (null vs))

	(defn fizzbuzz [n]
	(let [fb (str ({0 "fizz"} (mod n 3))
	({0 "buzz"} (mod n 5)))]
	({"" (str n)} fb fb)))

	const removeAt = (xs, i) => xs.filter((x, j) => j !== i);

	const permute = xs => xs.length
	? xs.flatMap((x, i) => permute(removeAt(xs, i)).map(ys => [x, ...ys]))
	: [[]];

	(defconstant mv-limit 20)

	(defparameter mv-expected 1)

	(defparameter mv (make-array mv-limit))

	(defun mv (&rest vals)
	(do ((i 0 (1+ i))
	(vs vals (cdr vs)))
	((or (eql i mv-expected) (null vs))

	(def mv-limit 20)

	(def ^:dynamic mv-arr)

	(def ^:dynamic values-expected 1)

	(defn values [& vals]
	(when (thread-bound? #'values-expected)
	(dotimes [i (set! values-expected
	(min values-expected (count vals)))]