This infests frontend as well. Instead of keeping things simple like Django for SSR + Lit for components, in addition to FastAPI/NestJS, teams bring on yet another framework like Next.js and turn the clean React client side model into a Frankenstein.

Most dynamic languages ecosystems default to big frameworks, so even small services end up heavyweight. They abandon Django monoliths for newer, shiny, “batteries included” FastAPI, etc. Clojure is different. It has a culture of small, composable libraries, which keeps microservices lean.

On the upside, the blog collects less personal data directly (GDPR) and the security risk is shifted by outsourcing it to a controller like Disqus, GitHub, Reddit or HN. The downside is the dependency on an external moderator, vendor lock-in, ads, tracking etc. WordPress supports Markdown blocks.

So, for the first group, the matheux, as the French say, the focus is primarily on mathematics as a tool for computations and verification, whereas the true mathematician seeks the elegance of abstraction. Of course, people can fall somewhere in between and modern languages are quite multi-paradigm.

I think people with a more applied (polytechnic) background tend to prefer imperative languages (C++, MATLAB, FORTRAN, Julia, etc.), while those with a more theoretical or abstract background are naturally drawn to logical/functional/declarative languages (Haskell, Lisp, Prolog, etc.)

Not long ago we were talking about GraalVM Native and now Oracle says Graal will focus more on non-Java languages, while AOT efforts for Java move under Leyden. blogs.oracle.com/java/post/de.... While I had fun building a toy Docker TUI with Lanterna, generating reflect config won't be missed.

Thanks for the post. haven’t used Scala in production, only for learning. I like its pragmatic direction, it aligns with the JVM. But with TypeScript for Node and GraalVM for native, does Scala multiplatform still have a strong market fit? Same thing for Kotlin and other languages that bet on that.

However, both parts now run in less than 2 seconds.

Go (cached) solution: https://github.com/bgbernovici/advent-of-code/blob/main/Go/2023/day12/day12.go
Go (snail-paced) solution: https://github.com/bgbernovici/advent-of-code/blob/main/Go/2023/day12_uncacheable/day12_uncacheable.go

#adventofcode

Go solution (with Dijkstra's shortest path, only part 1): https://github.com/bgbernovici/advent-of-code/blob/main/Go/2023/day11_dijkstra/day11_dijkstra.go

Dijkstra works well on the provided sample, but once the personalized matrix scales, it quickly becomes unfeasible.

I solved it in the end, as the community suggested, with LCM. (~4ms)

Go solution: https://github.com/bgbernovici/advent-of-code/blob/main/Go/2023/day8/day8.go

#adventofcode

Nowhere close to ideal, but they yield the correct results in the end.

One often overlooked quality of the Swift programming language is how easily it can consume C libraries, and more recently , since Swift 5.9, even C++ libraries. There isn't much impedance mismatch.

Source: https://github.com/bgbernovici/myndsmith

Source can be found at https://github.com/bgbernovici/word-guesser