London didn’t quite work out for us, and with a bit of encouragement from our landlord (who wanted a £400/month rent increase), we’ve decided to move to Amsterdam. We’ll be there starting in December — if you’re ever in the neighborhood, drop me a line!
Also: If you fancy yourself an interior designer, we’d love ideas about how to decorate and (more importantly for computing) place a sit/stand desk and its giant-TV-as-monitor in a open kitchen/living plan without totally destroying the vibe.
I had a transatlantic flight canceled on me the night before departure, which under UK regulations entitles me to £520 of compensation (in addition to a refund). It took a few emails, online forms, and months of waiting, but eventually I got it.
I’ve documented the process and exact emails I sent, which may be helpful for anyone learning to project “experienced bureaucrat” energy (a vibe that, shockingly, is always treated better by bureaucrats).
I had a blast at the last Strange Loop conference in September. It felt like a reunion of sorts, as the conference and community were quite influential in my early career — I spoke back in 2012 on building web interfaces as functions of plain data. (An idea which was “in the air”, which became extremely popular after React.js was released a year later.)
I’ve continued to build web apps in pretty much the same way since then: ClojureScript with an “Elm Architecture”, leaning heavily on Rum for rendering via React.js, DataScript for modeling application state, and a pile of duct-taped live-reloading SASS for styling.
I enjoy different aspects of the two languages.
What I can’t help but notice is that the qualities I enjoy about both languages aren’t obviously in tension with each other; could a language have it all?
My hypothetical combined language would probably give up some dynamic aspects of Clojure:
and also lose some of the more systems-oriented, memory/pointer orientations of Rust. (The biggest design unknown for me is how to handle static types and fiddly memory details — making them accessible when you have an opinion about them, but letting them fade to the background when you don’t.)
I’m curious to explore what such a language might look like, together with a few other aspects:
coherent compile-time metaprogramming: I’m not sure where the line is between “macro system” and “build system”, or if there should be a line at all! I’m curious to explore what it’d take to, for example, shell out to something like the Pinfigurator during compilation.
Many languages (like Rust) have a syntactically distinct templating / pre-processor / macro language, which feels at best completely separate and at worst a tricky, “bolted-on” pile of duct tape. A more holistic approach like Zig’s comptime feels more promising.
relational programming: Something like Alloy and what I explored in my relational spreadsheet — a way to succinctly specify and manipulate data at the level of projections, joins, filters, etc. without explicit iteration. Databases have done this forever, and I’m not sure why they can’t “scale down” to fit in-memory in a programming language. (Most of my experience here is with DataScript and I know SQLite is often embedded, but they’re still orders of magnitude harder to use than, e.g., creating a new array or map.) EdgeDB looks interesting, as does the Cell Programming Language.
web interfaces: It’s hard to beat the distribution of the web platform.
<canvas> (fast, but hard to do text/layout/accessibility).
The only language I’ve seen leaning into the web is Imba, which has dedicated syntax for markup and styling (and a great landing page tutorial!)
With the advent of WebAssembly, many people are now exploring compiling existing languages or designing new ones to use in the browser. I’ve done a whirlwind tour over the past few weeks, and these are the languages / features that I’ve found interesting (in no particular order).
I’ve heard good things about this for years and it strikes me as pragmatic language for people who want to get useful work done. Wlaschin’s Domain Modeling Made Functional is a great book on domain modeling for any language with algebraic data types, not just F#.
Hylo (formerly “Val”) is explores “mutable value semantics”, meaning the language has no concept of “references” (though the implementation will be smart and avoid needless copies). It’s implemented in Swift and seems to be an active research project.
The language itself doesn’t particularly inspire me, but I’m interested in it for implementation performance ideas.
Noulith looks incredibly fun and the author is wonderfully self-aware; the first section of the README is “Elevator pitches (and anti-pitches)” and the GitHub repository’s “about” is:
slaps roof of [programming language] this bad boy can fit so much [syntax sugar] into it
The author’s Designing a Programming Language to Speedrun Advent of Code is not just a great overview of Noulith, but of the considerations entailed in designing a programming language.
Features that I found particularly interesting:
1 < x < 7.
case 2*k + 1matches odd numbers)
_ + xis a function that, given an argument
a + x.
x max= yis sugar for
x = max(x, y)(in many languages only the arithmetic operators are so privileged, e.g.,
BEAM is the Erlang virtual machine, which was developed in the 90’s for high-availability telecom applications. It’s idiomatic to structure applications in terms of lightweight processes that pass around immutable data. The scheduler prevents infinite loops and crashes from starving other processes, and the VM supports livereloading and extensive introspection/debugging capabilities. See The Soul of Erlang and Elixir • Sasa Juric • GOTO 2019.
Some folks are working on an Elixir type system with set-theoretic types and semantic subtyping.
If I had to build a SaaS web app, I’d be torn between the decades-baked workflows of Rails/Django and this newer but-probably-technically-more-robust stuff built on the BEAM.
Gleam is a typed language on BEAM which can also compile to JS; implemented in Rust.
I gave this one a spin but couldn’t find many frontend web application examples. Big fan of the syntax decisions.
Lobster is a Python-looking statically typed language with “flow-sensitive type inference and specialization” and compile-time reference counting (lifetime analysis)
Koka, “A Functional Language with Effect Types and Handlers”.
Fennel is lisp syntax on the Lua runtime.
Nelua is a “Minimal, simple, efficient, statically typed, compiled, metaprogrammable, safe, and extensible systems programming language with a Lua flavor.”
I always find it easier to design trade offs in the context of a specific project or goal. I developed the Pinfigurator language while building a desktop wire bender (haven’t gotten around to writing that one up yet). My relational spreadsheet was built to solve my (toy) problem of allocating my investments.
In this case, I’d start by building the interfaces for prototyping hardware that we talked about last time — I have a sense of what I want to be able to build, but can’t exactly express it nicely in any of my current languages. I’d probably duct tape something together with Instaparse and Clojure/Script and then (once I liked the design) switch to implementing in Rust for performance and distribution.
Another approach could be to use this as an excuse to pick up a completely new language (F#, probably) to round out my visceral feel of relevant “prior art”, before then deciding whether what I really want is, in fact, different enough from existing options to warrant the effort to explore the design space.
What do you think? Do you have any favorite programming languages or features that I should take a closer look at? Let me know!
“The World’s Most Popular Painter Sent His Followers After Me Because He Didn’t Like a Review of His Work. Here’s What I Learned”
How To Secure Weapons-Grade Uranium: “It took a lot of salted dried fish and vodka”
Tips to avoid hurting yourself with the table saw
“Hauser’s law is the empirical observation that, in the United States, federal tax revenues since World War II have always been approximately equal to 19.5% of GDP, regardless of wide fluctuations in the marginal tax rate”