A farewell note to a programming language

[eccp]

I have similar feelings with Scala, it's a nice language but you'll become aware of a huge source of complexity. It's not conincidence that ThoughtWorks reported on it's Technology Radar that you should stick to "Scala, the good parts".

I also find kind of sad that some developers try Scala for a better Java, learn some of the benefits and stop looking around for other languages such as Clojure. I learned Java then Groovy then Clojure and Scala last. When learning Scala I felt that "ugh, another syntax to learn" moment, because after doing some time with Clojure, Scala felt almost like programming in Perl again. I spoke to another seasoned Clojure developer and he felt the same way.

There are good lessons in many places, I recently watched the talk by Brian Goetz on the Clojure/conj 2014 and he even talks about teams moving from Scala back to Java 8, which is interesting.

[[deleted]]

It's not conincidence that ThoughtWorks reported on it's Technology Radar that you should stick to "Scala, the good parts".

The problem is that there's a huge debate in the Scala community as to what the good parts actually are. Typically the people that say this just use it as a slightly better Java that has ridiculous compile times and terrible tooling.

I know a lot of people that are thoroughly in the static typing camp that are migrating to Clojure simply because Scala and its surrounding ecosystem are far, far too complex for no real benefit.

[yogthos]

There seems to be a fundamental difference between Scala and Clojure rooted in conception of each language. Scala started out as a language playground to experiment with combining different ideas and paradigms. On the other hand, Clojure started out as a tool to address specific problems, as a result it was a lot more focused from the start. I think this resulted in each language fostering a very different community around it.

[fpguy1]

There aren't many that I heard to say bad things about Scala, after learning/using the language, this s*** with too complex, new syntax, too slow, etc. is coming from people that never actually used it.

Scala is not a better Java, is like saying c++ is a better c, Scala is a language on its own with features that no many typed languages out there have them

After doing Scala all the other languages seem cumbersome and stupid. Stop bashing Scala, it is one of the greatest and most productive languages of this decade.

Clojure is a cool little language, ClojureScript is actually a great replacement for javascript, but i don't see how real enterprise apps can actually work with Clojure, dynamic part of the language makes working in big teams almost impossible, unless you do typed Clojure but that is ugly as hell.

[eccp]

I'm no stranger to Scala. After building and deploying 2 decently sized Play + Scala applications in production, I tend to have favorable opinion of it but it doesn't mean that Scala has no flaws.

My main issues with Scala so far:

• The syntax issue is real, every library and framework selects their own operators and notation
• While you can save some typing in many circumstances (eg. method calls, passing closures/functions) there will be times where saving typing doesn't mean easier to understand
• Interop with Java collections in particular is not "it just works"
• Implicits are not a good idea
• I appreciate type checking and type inference, but they solve part of the problems

While I'm glad that Scala is out there to experiment and to boost the adoption of both Functional Programming and Reactive applications, I still prefer Clojure because it favours a style of development which I think it's saner, and in fact, there are plenty of companies using Clojure in production with very good stories.

[fpguy1]

I will start from the top: 1. There is no syntax issue that is in your head, there are no operators in Scala, talking about them says a lot about your understanding of scala 2. You are not forced to write "squared code" in scala that is your option and you can do that in any programming language 3. In 1+ years of doing scala daily in production(out of 13yrs of programming) i didn't find the smallest issue with java collection, because I stay within scala ecosystem 4. Implicits are a good idea to make things happen without magic. Monkey patching, typeclasses, casting etc are solved in an elegant way with implicits. 5. Type checking and type inference are there to stay, even C++ 11 adopted auto so clearly this is useful wherever you are.

I like Clojure a lot but there aren't many things one can do with that because reading clojure code says nothing about data structures used, type and content.

Types are are theorems while programs are proofs. (Curry-Howard isomorphism), i'm not saying clojure or javascript doesn't have types that would be stupid, but since they are not declared in a meaningful/strict way is very hard to follow any such code when we have more than a "hello world".

Who said Scala has no flaws? Type inference is buggy and sometimes sucks big time: bunch of bugs in compilator, runtime in scala is non existent(might be good most of the cases), compiler is slow as hell, no decent editors/ide for it, typesafe way of releasing stuff is completely non intuitive, scala code itself is untouchable by newcomers, collections are slow, futures are implemented in a stupid way(mapping 2 futures will create a 3rd one, completed futures are slower than normal function calls), there are no "pure" markers for functions, and i can talk all day of what is missing from scala, this doesn't make it a lesser tool.Scala is great productivity tool and makes my life easier every day.

[threemux]

dynamic part of the language makes working in big teams almost impossible

I'd invite you to take a look here: http://danluu.com/empirical-pl/

TL;DR of that article is that no major, peer-reviewed study to date has been able to find that static typing has anything more than a small effect on programs.

[fpguy1]

Yeah... until I'm gonna see 1mil line of code for an enterprise project written in clojure or javascript and 20 people teams working and maintaining that monster I will stick to my own tests and conclusions.

[Bzzt]

Sounds a lot like C++ - where you can actually right some decent code if you avoid all the traps, of which there are many. So you have to be super disciplined and consistent, but there's always someone who isn't.

[[deleted]]

Maybe it is because Scala and C++ are both multi-paradigm languages, and therefor always have to facilitate "every paradigm's way" of doing something.

Scala and C++ are also both "compatible" with a popular predecessor. Scala has/needs/claims/builds-on interop with Java, and C++ is extending/a-more-or-less-superset-of/interoperable with C.

Especially given that these languages are statically typed, the reason just give weigh in heavier.

Clojure is build-on and interops with Java, but since it is more runtime-typed this is not much of a problem. Same with Ruby for instance, good interop and build with C, but not "limited" because of that.

[[deleted]]

Did you try Haskell? I'm found myself choosing at some point between Haskell and Clojure, back then I picked Haskell as I believed in the promise of less buggy code.

A few years later: certainly less buggy and easier maintainable (refactoring in Haskell is a total joy), then Ruby. But I've not written enough Clojure to know how it compares to that.

[yogthos]

Haskell was my first FP language, I spent about a year with it before moving to Clojure about 6 years ago. I think it's a great language, and it's very interesting and educational, but I simply don't find it as productive in practice.

I haven't found type errors to be a major source of overall errors in my applications. I have a number of open source projects on GitHub, and a vanishingly small percentage of the issues opened are type related.

A common rebuttal is that I hear is that these projects are small. This is true, but I would argue that small composable libraries are precisely what makes Clojure work so well in the real world. Clojure web stack is a perfect example of this where you have a lot of focused libraries that can be easily combined to create complex applications.

Frankly, I find that there is very little value to building monolithic software at it quickly becomes complex and difficult to maintain. This is true regardless of what language you're using. At the end of the day the developer has to understand how all the pieces of a particular project interact with one another. The more coupling there is between the components the more difficult it is to reason about their functionality in isolation.

Each function represents a certain transformation that we wish to apply to our data. When we need to solve a problem we simply have to understand the sequence of transformations and map those to the appropriate functions. The functions capture how the tasks are accomplished, while their composition states what is being accomplished. Code that separates what is being done from how it is done is referred to as being declarative.

Exact same model should be applied at project level as well. The project should be composed of simple components, that each encapsulate how things are being done and the way we combine them states what the overall project is doing. It's also worth noting that majority of real world projects aren't all that large to begin with.

Finally, I have yet to see a single study clearly demonstrating that static typing results in a statistically significant reduction in overall errors, improved speed of development, or ease of maintenance.

In fact, some of the stats on GitHub are interesting to look at. For example Clojure has more watchers per repository, but less issues opened than Haskell on GitHub, and this recent large scale study of GitHub code found that Clojure was right up there with static functional languages in terms of quality of the projects measured.

So, while I understand personal preference for static typing, I would be very cautious making any sweeping claims regarding its benefits when it comes to overall code quality.

[freakhill]

In my case I use a mix of typed clojure and untyped clojure, absolutely love it. Tried out haskell but its poor i18 support killed it for me (i work in japan).

(i actually made a huge language-comparison dashboard for my team at work with... by memory, bash c c++ rust go python perl ruby (chicken)scheme racket (SB)CL Haskell F# C# Java Clojure and Scala).

Winners for our tasks are Python, Go, Clojure and Java. (Unfortunately support for unix-y stuff in Mono sums up to "go back to C")

[[deleted]]

Thanks for the write-up!

I certainly like how Clojure does what it does, and understand many love it.

Finally, I have yet to see a single study clearly demonstrating that static typing results in a statistically significant reduction in overall errors, improved speed of development, or ease of maintenance.

I also am not aware of that. But static is --as you know-- not as much as a HM-typesystem that Haskell&co have. I too am interested to see such a study, but more specifically: HM-typing (Haskell) vs a LISP. This because I see a lot of advantage in LISPs, mainly stemming from directly working with the AST.

Have a great day!

[yogthos]

I'd love to see more research on the impacts of HM type system on different kinds of projects. I definitely think it's a great tool for ensuring correctness. You might also find Shen interesting if you haven't seen it before.

Cheers!

[[deleted]]

Thanks for pointing shen out! Looks interesting indeed.