- Wondering whether Perk 6 should be named as a totally different language
- A look at “typed Lisp”
- Bob Martin on “why Clojure”
- Rakuten And Egison
- In defense of stable platforms
- And now, a quote, something about languages both natural and artificial, spoken and digital:
It makes perfect sense to say that the target demographic of English is English speakers—or more precisely, the target demographic of Modern English is Middle English speakers who wanted a few simpler rules, some continental vocabulary, following other contemporaneous European languages in not having þ and distinguishing i and j, etc. It was a relatively small change and very intentionally served a community of people who already spoke Middle English well. It was the Python 2-to-3 of English.
The target demographic of Esperanto, meanwhile, was the whole world: people who already had a language, people who already had a workable lingua franca in international contexts (French, later English), and in particular people who weren’t familiar with the European language patterns that Esperanto was largely based on. So it had limited success. A Japanese or Indonesian or Persian or Swahili diplomat not familiar with any European language would be better served learning French or English than Esperanto, because those languages are roughly equally foreign, there are many more resources for learning French or English, there is a larger community and more people to speak to, there is a larger corpus of works, etc. And an Anglophone or Francophone diplomat has very little incentive to learn Esperanto, either.
Modern Hebrew, on the other hand, had a well-identified target demographic: Jews from around the world migrating to the reestablished state of Israel who lacked a shared everyday language. Some liturgical Hebrew was already familiar to most of this population, and there was a strong cultural willingness to see a reestablished Hebrew language. So while it is in many senses a conlang, it was far more successful than Esperanto and now has a large community of native speakers.
So the question of whether a programming language—especially one that is so much like a conlang, not an incremental evolution based on use in practice (like the C standards committee accepting compiler-specific dialectal changes)—has a target demographic is a fair one.
(yep, not a lot this month …)
The shrew-like networked GUI equipped microcomputers of Apple were released as products only two years after this central planning dinosaur was postulated. Eventually, decades later, someone built a mechanical golem made of microcomputers which achieves a lot of the goals of fifth generation computing, with independent GUI front ends. I’m sure the Japanese researchers of the time would have been shocked to know it came from ordinary commodity microcomputers running C and using sorts and hash tables rather than non-Von-Neumann Prolog supercomputers. That’s how most progress in engineering happens though: incrementally. Leave the moon shots to actual scientists (as opposed to “computer scientists”) who know what they’re talking about.
As I’m absorbing more of the general flavor of event-streaming and everything around it (… in the beginning was the log …), I keep gettin a bit of deja vu and realized that there’s an uncanny resemblance to something else, a different place I’ve encountered similar relationships between things in a different concrete form … in Clojure.
I feel Clojure keeps getting compared to other “languages for talking to machines”, and discussions tend to end up rehashing either the static-vs-dynamic-typing cliche, the lisp cliche(s), the scripting-Java cliche, and so on.
What is missed (I feel) is the symbolic nature of the language, which allows it to really represent concepts at an arbitrary level of abstraction … something that will be incomprehensible if all you ever compare it to is examples of computing factorials in other languages.
In particular, it is a sort of “language of the system”. The same patterns I see Apache Kafka getting involved in, for distributed data-processing systems, are the patterns I imagine with symbolic objects in Clojure code.
So instead of a log with brokers and producers and consumers and streams, I see …
LazySeq, with transducers; instead of Schema Registry,
spec … and so on.
This is not a fully-formed thought yet, but … dunno, I’m enjoying this parallel so far.
- Compiler comparisons: C2 vs Clang (JIT vs AOT), then C2 vs GraalVM (two JITters)
- Somewhat funny: The evolution of a Scala programmer
- Transitioning from “Next” to “Swift” for Apple
- Nice survey of IDEs and other tools, and their tradeoffs, and when complexity might be warranted (and somewhat more specifically, a look at Neovim)
- A rant of sorts on how machine-learning systems are stuck today
- “Interesting ideas in Datasette”
- Things you take for granted and never quite thought about: _level design in 2d games_
- Dug up an old article that should quiet people complaining about the lack of hash-table literals in Common Lisp
- Wonderful website: Apollo 11 in real-time (!)
- A look at Tesla’s new self-driving computer
- Using Pharo (smalltalk) for modeling, (specifically) Bioinformatics
- A look at Self
- Chuck Moore on 50 years of Forth (!)
I’ve started a new blog or a new online journal so many times, some private, some public, that I’ve really lost track of all of them. This is mildly complicated because some of them were pseudonymous.
At some point, I’m going to try to merge them together (I’m guessing that means exporting-and-importing), but it’s still a bit of a revelation to discover all this stuff I wrote, almost exactly five years ago (!)
Edit (July 11 2019): It turned out to be fairly straightforward to export the old blog and re-import it into this one — the hard part was figuring out what my login/password was, five years ago! — so this blog now goes back to 2014!
- Speculation on “next-paradigm programming languages”
- On the “struggles of an open-source maintainer” (by the maintainer of Redis)
- Stretching the computational metaphor too far …
- An overview of systems programming languages
- I know some readers will like this: Gopher and the web (gopher link here 🙂)
- Historical flash-back of the month: a 1965 edition of Computers and Automation; fast-forward to page 28, “… the debugging era begins” (yes, spoiler: we’re still there …)
- Another one, this time about Hypercard (either because you know about it already and would like to know more, or because you don’t, and you really ought to know more!)
- And yet another one, this time about early browsers in the 1990s (before Netscape!)