Our great sponsors
-
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
excoptional
A fully typed, zero-dependency implementation of the functional programming Option object for JavaScript and TypeScript
-
cafe-latte
An implementation of Common Lisp dynamic variables, control flow operators, and condition system in plain Java.
-
WorkOS
The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.
before compiling / interpreting. This rewriting happens as many times as necessary until an expression "bottoms out" and can be evaluated in terms of only built-ins.
It's instructive to see how much of e.g., Clojure is implemented as macros. https://github.com/clojure/clojure/blob/master/src/clj/cloju... shows pretty clearly the correspondence between the original form and the rewritten form in the definition of `when`. `defn`, which is so foundational to idiomatic Clojure that it's easy to mistake it for a built-in, is a much more complicated example.
I wonder if we'll end up with something like https://www.circle-lang.org/ which lets you use pretty much the entire C++ runtime language at compile time.
I wrote this to try and show how that could happen in a realistic enough way to make sense:
https://github.com/codr7/whirlisp
Lack of macros makes nothing impossible, but also makes many things harder. I think of them as code generators, tiny compilers on a micro scale; they are invoked by the proper compiler during compilation phase, as opposed to runtime, allowing you to inject code that you'd otherwise need to inline by hand.
It's possible to write pretty complex things like control flow abstractions using just structures and functions/methods, e.g. a CL-esque condition system in Java which only uses classes, static methods, and Java lambdas[0] for its syntax. Possible, but also IMO ugly when compared to the CL counterpart, because the low-level but irrelevant details (such as instantiation via `new` or generics) are still presented to the programmer.
[0] https://github.com/phoe/cafe-latte
I'll recommend the videos from the 1980s and this version of the text, which is set nicely and has working footnotes.
Videos: https://ocw.mit.edu/courses/electrical-engineering-and-compu...
Text: https://github.com/sarabander/sicp (links to epub and html versions at the top of the README)