This week was a busy one for me personally. But I did not fail to miss the popular discussion about the coming doom for dynamic languages. It was a very nice expression of the original promise of blogs: longform discussion, like we still see in Philosophy circles, but without the publication overhead. I enjoyed following it very much.
You'll find three articles in this week's issue that follow a typical dialectic pattern. They did not occur in that chronological order, but this reading has a good conclusion.
Of course, the arguments in all of the articles are flawed in one way or another. And they also contain a lot of truth. We just have to remember that this is an old debate started by some very smart people before programming became a profession. We won't find a conclusion any time soon.
We can, however, look at the good things of our languages—both static and dynamic—and build languages that combine the best of both worlds. For instance, Unison combines many aspects typically found in dynamic languages into a fully statically typed system. I'm really looking forward to more experiments like this.
Please enjoy the issue.
There are great, free materials for learning Clojure for both beginners and intermediates, and the number is growing every day. This article collects some of the best resources and groups them by type.
A great breakdown by Nicholas Kariniemi of what happens when you load a Clojure program.
There's a lot I agree with but a lot I disagree with in this essay. The article tries to tie together type uncertainty in dynamically typed languages, literal data structure DSLs, and null pointers into one overarching "dynamic language" umbrella. Although I don't agree with his overall sentiment (I think it's more subtle), I have experienced all of those troubles. And I think type safety is the future.
Allen Rohner gives us a look at techniques available in the ClojureScript compiler to make the load faster. Not to make the run faster, but to download and parse more quickly. Very interesting stuff.
Chris Houser explains how popular exception libraries for Clojure work, then shows how something similar can be created when needed without using an external library—it's a simple use of the existing Clojure features.
A nice interview with a DBA who has gotten into functional programming. One of the cooler things he talked about was how nice it was that the database was often the bottleneck when used from a functional language.
As a response to the Thesis article above, Dmitri Sotnikov explains some of the troubles he sees in static languages. His argument is ok, though many people will fault him for his specific examples. In my experience with programming Haskell professionally, I all too often ran into libraries with fantastically complex types—much more complex than necessary. My interpretation of the cause is that we as an industry are still discovering how best to use types. Eventually, we'll find the contours of the design space, and know how best to use them. Types will find their place.
A really great article by Maxime Chevalier-Boisvert which really hits home for me. There's a really great point in there about how most dynamically typed languages that people use are poorly designed languages in general. And she concludes with the beautiful idea of dynamic and static typing influencing one another and making each other better.
Refactoring JIT Compilation Youtube
A talk by Maxime Chevalier-Boisvert about her platform for JIT compiler optimization research.
A proof of concept by Mike Fikes showing ClojureScript powering React Native Desktop.