Apologies if this question isn’t really appropriate for this community, but Rust and Kotlin are my two favorite programming languages, and currently, I use both for different projects. However, I’m curious as to if people here think Kotlin still has a place when Rust exists? I’m specifically speaking architecturally: disregarding existing legacy code or support, do you think in the future, the Rust platform should replace the Kotlin platforms (JVM, LLVM Native, Android, Web) for everything Kotlin can do, or do you think Kotlin can do some things better than Rust?
My team uses Clojure with ClojureScript on the frontend and I haven’t had to touch a line of Js in years. It’s simply a compile target from my perspective. Unlike stuff like typescript that builds on Js, ClojureScript has its own semantics that are actually sane.
I’ve also developed a strong preference for s-expression syntax nowadays. It eliminates a whole class of problems you see in Js. Stuff like JSX is completely unnecessary because you can just use regular data structures instead of having yet another transpiler as seen in React. The code is also a lot more regular than in most languages I’ve used. This means that it’s less ambiguous and you have less syntax quirks and edge cases to worry about.
Structuring code as a tree shows how pieces of logic relate to one another. This makes code more easily scannable. If one function is nested in another, you know its output will be used by it and if it’s not then it won’t. Effectively, your code is written as a diagram that you can inspect. These kinds of relations are not explicit in most languages.
The parens also allow for things like ParEdit where the code can be manipulated structurally by the editor. You can select an expression, reparent it, move it around etc. You’re no longer working with lines of code, but with little blocks of logic. Editing code becomes like playing with Lego, where you just snap pieces together to make things.
Using data structures to write code is what allows for a powerful macro system. You can take any piece of code and transform it like any other data structure using the same functions you’d apply to manipulating any other data. A good macro system means that you can express most things in user space instead of having to bake them into the language.
Most new ideas in Clojure are expressed via libraries, and when something new comes along people can just start using new libraries while existing projects keep on working. This greatly reduces mental overhead of working with the language. A concrete example of this is the core.async macro which allowed doing async in ClojureScript before it was even available in Js, and people didn’t have to wait for the language design committee to agree on adding this functionality in.