Part of my motivation to prefer Kotlin over Clojure (the most popular LISP on the JVM langauge?) is that I am a huge proponent of static typing. Large programs written in statically typed languages are orders of magnitute more readable, more maintainable, easier to understand, and far less error-prone, than programs written in dynamically typed languages.
The recent surge in popularity of dynamically typed languages like JavaScript, Python, Ruby, etc, had been a source of horror and frustration to me. It feels like a huge segment industry is throwing away decades of advancement made in programming language research, and instead of moving to languages with more advanced type systems, they're abandoning sound typing altogether (shudder).
It's possible I suck at what I do, but somehow I've enjoyed building, shipping, and maintaining services and applications in dynamic languages.
I used a lot of Clojure, and it was basically smooth sailing, even on teams.
Along the way I used various statically typed languages, such as C# and a tiny bit of SML (to be able to read Okasaki), and enjoyed them too. Just not as much.
Anyway, I can't refute your experience programming, or the way that you feel. With more experience, perhaps some day I will agree with you. But right now, for whatever it's worth, I don't.
Dynamic (functional) languages all the way.
Even just in terms of reading and understanding what was going, there was no way to know the structure of objects passed to various function. A function would take an object foo, which had some arbitary strucutre and set of fields that were not defined or specified anywhere. Pure hell for readablity (i.e. understanding someone else's code). The absence of type system enforced structure on objects, means these objects could contain anything. Grr.
Everytime I get in production, a run-time JavaScript TypeError that would never happened had it been written in a statically typed language, I want to grab people like you by the collar (proponents of dynamically typed crap), and punch you in the face and give you a bloody nose.
I think you have to be slightly fucked up mentally to not appreciate the beauty, the power, the clarity, and the safety that high-quality type systems bring, in languages like Agda, Haskell, Elm, Swift, Kotlin, etc.
Dynamically typed languages are a bane.
This is not to deny that some statically typed languages have a poor type systems. Early Java had a disappointingly weak and primitive type system (e.g. no generics). Scala's type system is so complex that it's worse off for it. Etc.
But solid type systems are a huge advantage. I wish more people invested time researching and building more advanced and better type systems. We'd all be better off for it.
That's your belief, not a fact.
> The recent surge in popularity of dynamically typed languages like JavaScript, Python, Ruby, etc, had been a source of horror and frustration to me. It feels like a huge segment industry is throwing away decades of advancement made in programming language research,
It is exactly the opposite. Mainstream programming languages are recently catching up with features that are more advanced but weren't popular before, like functional programming, metaprogramming and dynamic programming.
If you're into static typing on the JVM, then Kotlin is the best choice because it's got the best-of-breed types. If you're into dynamic typing on the JVM, then Clojure is the best choice because it's got the best-of-breed macros.
What I can't fathom is why anyone would choose a language that's dynamically typed but without any macros, or only tacked on static typing later on as an afterthought. Apache Groovy comes to mind for the JVM as a language which did both.
Edit: Macros are great for simple elimination of repetitive code in bulk tests, but Groovy's Spock hacks into the statement labels and operator overloading in a clumsy attempt at an alternative. And Groovy's backers only added some static typing in version 2.0 because they were afraid of someone else's addon (Groovy++) taking away their control.
Recently I have to give huge props to Guile + Andy Wingo for guile-fibers. It's proper concurrency, using delimited continuations in scheme. Just frickin' fantastic!
And a paper (2013) giving some details and explaining their motivations: http://ecem.ece.ubc.ca/%7Ecpetersen/lambdanative_icfp13.pdf
Thanks for the links.
BTW shameless plug: If you're interested in this type of ideas, please also check out Jasonette (an open source project I'm working on) Just like this project uses "list" to describe an app, Jasonette uses JSON to describe an app. https://www.jasonette.com
With gambitc you are already there.
