Perhaps a Lisp shop could force consistency, but that seems to fall apart after a while.
More on this viewpoint: http://wiki.c2.com/?GreatLispWar
Perhaps a Lisp shop could force consistency, but that seems to fall apart after a while.
More on this viewpoint: http://wiki.c2.com/?GreatLispWar
1. It shipped with a substantial set of features, either in core from day one or as a function of being hosted on the JVM, that programmers would otherwise have been likely to build themselves in multiple, potentially incompatible ways.
2. The syntax is simple, and Clojure doesn’t allow user-defined reader macros, so libraries can’t introduce new syntax. There may be more than one way to do it, but you should at least know how to read all of them.
3. It’s only ever been under the stewardship of one cautious, opinionated developer.
Of course, from another perspective, all of these could be (and I’m sure have been) seen as weaknesses.
Objective C and Swift for iOS.
Javascript for the Web.
Java (and now Kotlin?) for Android.
SQL for relational databases.
Visual Basic and C# for Windows.
Python for scientific programming and machine learning.
Developers don't pick a language because it makes them feel productive. They pick a language that allows them to write for the platforms where they want to deliver their programs. Or because it has the best libraries for their problem domain.
(Back end web development is somewhat of an exception, as every language can talk HTTP.)
C++ and Mac OS, OS/2, Windows, now games and GPGPU shaders
Most people are in the middle of the bell curve. Smart persistent people are out at the edge of the bell curve.
So where should you aim your project?
There's cult kudos in being out on the edge, and there may even be real productivity and reliability benefits.
But realistically, most people aren't going to go there most of the time.
I can't speak to Clojure; I'm still learning it and haven't used it professionally. But it seems promising insofar as it seems to be quite opinionated. Groovy and Scala aren't. So they both have a lot of concepts to learn, and those concepts all overlap and interact in surprising ways. On my team, I've started banning certain parts of Scala from the codebase. Not because I think they're bad features, per se, but because carving the language down to some semblance of an orthogonal subset seems to be the only way to ensure that 4 programmers won't solve the same problem 6 different ways in the same codebase.
I run into the same problem with Haskell. Haskell's a great language and I think everyone should put some time into learning it. But it was designed as a language research platform first and foremost, and that's evident everywhere. So I'm hesitant to try using it on a large team. I'm kind of hoping that someday someone will produce the Haskell equivalent of Clojure. It doesn't need to try and be minimalist like Scheme. It just needs to have fewer than 5 string types, and save the senior developers from having to spend 85% of their time coaching the junior developers on when to choose a monad and when to choose an applicative functor.
Like I said, I don't know much about it other than it's a pure functional language that compiles to java byte codes, so I lump it in with Groovy and Scala which are both in the same family. Maybe it is easier - Groovy and Scala (as much fun as they both are) definitely aren't. Isn't it as "pure" a Lisp as they can get away with and still run on a JVM though? Lisp has sent many worthy men screaming for the hills.
Not saying that it won't improve, just stating the current state.
Even with reactive UIs as way to get around those callbacks, relm isn't as easy as Fabulous, SwiftUI, Elm, with the caveat that reactive UIs are heavier on the memory allocator.
This was one of the main goals of the Common Lisp standard, no?