fogus

# books that helped form MY thinking about technology/programming/systems


## more so

Architecture of Symbolic Computers by Kogge
Art of the Metaobject Protocol by Kiczales, et al.
Bootstrapping by Thierry Bardini
Commodore 64 users guide
Computer Lib / Dream Machines by Ted Nelson

bhb

;; clojure 1.8.0 - lein repl

user=> (defn hello "hello world")

IllegalArgumentException Parameter declaration missing  clojure.core/assert-valid-fdecl (core.clj:7181)

;; clojure 1.9.0-beta2 - lein repl

user=> (defn hello "hello world")

reborg

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

non

What is the appeal of dynamically-typed languages?

Kris Nuttycombe asks:

I genuinely wish I understood the appeal of unityped languages better. Can someone who really knows both well-typed and unityped explain?

I think the terms well-typed and unityped are a bit of question-begging here (you might as well say good-typed versus bad-typed), so instead I will say statically-typed and dynamically-typed.

I'm going to approach this article using Scala to stand-in for static typing and Python for dynamic typing. I feel like I am credibly proficient both languages: I don't currently write a lot of Python, but I still have affection for the language, and have probably written hundreds of thousands of lines of Python code over the years.

fogus

(ns lisp-ch1)

(def self-evaluating?
  (some-fn number? string? char?
           true? false? vector?))

(defn -atom? [s]
  (or (self-evaluating? s)
      (symbol? s)))

amalloy

(def levdist
  (let [lev (atom nil)
        impl
        (fn [s t]
          (let [lev @lev]
            (cond
             (empty? s) (count t)
             (empty? t) (count s)
             :else (let [ns (rest s)
                         nt (rest t)]