Are there any plans for exposing a Clojure API? Given that it's implemented in Clojure, seems like it would be a natural fit. Interop with Java is nice but can be cumbersome compared to the more natural calling conventions and idioms (threading macros instead of `..` builder patterns, etc).
Reader macros/literals allow for explicitly differentiating between built-in data types, and provide semantic meaning to otherwise indistinguishable forms. For example, defining a function:
In Racket, you write `(define (foo arg1 arg2) (+ arg1 arg2))`. Why isn’t `(foo arg1 arg2)` evaluated as a function? It’s a list and it isn’t quoted, so it should be evaluated. However, `define` is a macro (I think, might be a special form), so that list isn’t evaluated and doesn’t have to be quoted. That violates the basic tenant of “unquoted forms wrapped in a list are evaluated as fiction calls.”
In Clojure, you write `(defn foo [arg1 arg1] (+ arg1 arg2))`. The [] is a reader macro, a vector literal. It communicates that it’s not a function call but simply data (in this case, a vector containing two symbols).
Maybe I’m just used to it but I find this stuff really helpful.
I roughly agree with you but in your deps.edn example, how would you like the tool to respond? Your map/dictionary/object has an uneven number of forms, so what else would you like it to say?
I just tried breezethat and had to scroll past 6 ads (two screenfuls on my iPhone 10) to see a single result. I know ads are necessary but this is punitive.
Wow, massassi.net is quite a trip through time. I spent many many hours on your site, playing Jedi Knight with friends and randos through GameSpy. Endless hours of entertainment toying with JED, trying to perfect my own levels, or installing various mods and texture packs.
Thank you for the effort, you gave me quite a few cherished memories.
Clojure has that built-in and it’s great. Works wonders when testing things too: write a small test in a comment block and you can edit/evaluate a function then move to the comment and see the result immediately.
I love that “hacking language learning” turns out to be “mostly do what babies do”: consume as much content as possible. Babies take it one step further by trying things without embarrassment or any attempt at “getting it right”, only focused on raw communication.
Not to denigrate the efforts of folks who study and practice “the act of language acquisition”, I’ve just been surprised and delighted to watch my now 2 year old daughter learn to speak, which has made me think about how different her experience of “learning a language” is from all of my poor attempts at learning foreign languages.
I wonder if a `loop`/`recur` construct like the one Clojure has would help here. Allows for closing over data without having to pass everything into a recursive function, and can handle more complex looping constructs without having to write an explicit "for loop".
For all their sneering at traditional philosophy, rationalists (and specifically the Less Wrong community) love to rewrite traditional philosophy in techy terms while missing most of the underlying meaning and depth. For examples, large portions of The Sequences are Plato’s The Republic but worse or Wittgenstein’s Philosophical Investigations but worse.
The whole point of that section is that he wasn't there. He'd taken time away to get a Masters of Fine Arts, and this paragraph was his reaction to re-entering the world of programming and software. Coming back after 5 years and seeing that the journal he'd started that was focused on symbolic computation using Lisp has now expanded to include using other languages doesn't mean Lisp is forgotten.
I browsed the titles of a bunch of the articles published by the journal after the name change, and most of the were language agnostic but still lisp-adjacent and potentially lisp-relevant. (For example, Volume 12 Issue 1, the second year with the new name, has multiple articles about call/cc using demonstration languages.)
I like the writing style and voice in this essay. I disagree with some of the assertions but I enjoyed my time reading, which doesn’t happen a lot with most tech-related essays.
I will say, however, that this paragraph felt like sour grapes:
> As examples, the scientific journal Guy Steele and I founded called Lisp and Symbolic Computation (LASC) had been renamed Higher-Order and Symbolic Computation (HOSC), and my primary scientific conference called Lisp and Functional Programming (L&FP) had been renamed the International Conference on Functional Programming (ICFP). I was discouraged for two reasons. One was that during the 1980s when functional programming researchers had few outlets, many of us Lispers kept the lights on at L&FP for them, and later when Lisp was on the decline, they shut the door. And the other is that this seemed to signal that my field of inquiry had been deleted by the academy.
All that’s changed is that Lisp isn’t primary anymore; they are both titled to allow other languages and other media to contribute to their respective focuses. Common Lisp is a good language but it’s not the final language nor even the final “programming medium”, so acting like it is artificially limits both Common Lisp users and future language designers who could all benefit from that cross-pollination.
Now maybe the change of names is shorthand for lisp actually being excluded from the journal and conference, which nullifies the above, but without doing any research at all lol, I doubt it.
It can be slightly inconvenient but doesn’t feel moronic to me. It means that except for the built-in functions, everything can be traced to either a definition or an import. Makes tracking code much easier.
> Another one is having to import everything you use.
The alternative is what exactly? Have the entire standard library exposed at once? Make all modules create non-conflicting names for exported objects, so that the json parse function has to be called json_parse and the csv parse function has to be called csv_parse?