3 ms·

I guess it depends on where one comes from. If one compares Scala to Scheme, sure, Scheme is ridiculously simple compared to Scala. But if one compares Scala t

I guess it depends on where one comes from. If one compares Scala to Scheme, sure, Scheme is ridiculously simple compared to Scala. But if one compares Scala to languages which are actually used in the wild like Java, C#, PHP or C++; Scala's footprint is just incredibly small. All of the features you mentioned are available in languages like Java or C#, too. The difference is that in most cases the implementation is so poor and incoherent, that the feature is next to useless. I guess one just "sees" more language features being used in Scala, because almost everything which ships in the language makes some sense, while in Java/C#/PHP/C++ you have tons of utterly useless "features" which don't add any benefit, but still force people to learn them in case somebody else used them. I have never seen "On a sufficiently big project with one or more extra clever developers most probably every feature will be used" happen in real life. In my experience one of the strengths of Scala is the way one can use some advanced feature where it makes sense, without having it bleed through the whole code. Compare that with Java's, C#'s "Oh, you used some complicated Generic type over there? Guess what, we will make every user suffer from it throughout your whole code base!" In a sense, I prefer a language (Scala) which ships with 100 features where 90 of them make sense to a language which ships with 400 features where only 50 make sense, like C# (multiply "feature" count by 10 for C++). > And I don't need a compiler to catch errors that a unit test would also catch. Well, using the compiler means that it will also catch errors which you haven't written unit tests for. Tests can't prove the absence of certain categories of errors, compilers can.

qammm 13y ago
I don't want to sidetrack that thread as it was about Clojure. Just a quick correction: Java has no type inference, higher order functions, coroutines, implicits (it has some standard implicit conversions but not implicit conversions that can be added by the user) and no Turing complete type system. And of course: Using a statically typed language is no excuse to not write unit tests. Unit tests serve as a safety net checking if the behavior of the implemented unit is (and stays) correct. As a side effect this will also find all type errors a compiler will find. I have programmed a lot in Java and also in dynamic programming languages and in my opinion type errors just don't happen often enough to justify the additional amount of work and complexity that comes with static type systems. However I'd agree that if you want to get the best possible performance you probably need a statically typed language as the compiler can then optimize the generated code better.
- happy_dino 13y ago
  > Java has no type inference, higher order functions, > coroutines, implicits (it has some standard implicit > conversions but not implicit conversions that can be > added by the user) and no Turing complete type system. Type inference in Java: int bar = new Object(){ int foo = 42; }.foo; // Magic? No. Type inference. Higher order functions in Java: http://download.java.net/jdk8/docs/api/java/util/stream/Stream.html Looks pretty higher-order to me. Also possible in older version in Java with stuff like Google Guava or FJ. Coroutines in Java: http://stackoverflow.com/questions/2846428/available-coroutine-libraries-in-java Implicits: Having them built into the language is even worse. In Scala you could just de-import them and have them gone. Anyway, pick C# as an example instead if you want to have user-defined implicit conversions. No Turing complete type system: interface Interface<T> {} class Bang<T> implements Interface<Interface<? super Bang<Bang<T>>>> { static void bang() { Interface<? super Bang<Byte>> bang = new Bang<Byte>(); } } Looks pretty undecidable to me. In a way, it is even worse than other languages: You are unable to tell whether the type checker will terminate in finite time (like some other languages), but don't get any additional expressivness in return (unlike those other languages). > As a side effect this will also find all type errors > a compiler will find. No, absolutely not. > I have programmed a lot in Java and also in dynamic > programming languages and in my opinion type errors > just don't happen often enough to justify the > additional amount of work and complexity that comes > with static type systems. This comment certainly explains a lot. You are suffering from the "I used Java and Java is statically typed and it sucks, therefore all statically typed languages have to suck" fallacy.
  - qammm 13y ago
    It seems we have different definitions of what type inference, higher order functions and Turing completeness means. :-) Regarding coroutines in Java: I don't know if libraries using native continuation mechanisms or bytecode manipulations prove that Java (the language) has continuation support. :-) I don't have anything against Scala. In my very first message I even said that I see the odds for Scala winning higher than the odds for Clojure winning - because I already see some enterprise adoption of Scala. Although I see the probability of Scala winning quite low. As you noticed with Java 8 Java is already borrowing a lot of useful things from Scala. I am sure conservative corporate decision makers will see less and less reasons to switch to Scala as time passes by. Also I don't think that Java sucks. I was just making a point from personal productivity experience. Your experience might differ from that. If I have a function: def upcase(s: String): String... The compiler with its static type system can tell me if e. g. I am trying to call the upcase function with an Int argument. But in my experience something like that just does not happen very often. Most programmers are not so stupid that they try to fit a square peg in a round hole. ;-) A unit test can check if the returned string is really the upcase version of the input parameter. Plus if the programmer would really assume that he could upcase an Int it would just as well give the feedback that his assumption was wrong-like the compiler.

qammm 13y ago

I don't want to sidetrack that thread as it was about Clojure. Just a quick correction: Java has no type inference, higher order functions, coroutines, implicits (it has some standard implicit conversions but not implicit conversions that can be added by the user) and no Turing complete type system. And of course: Using a statically typed language is no excuse to not write unit tests. Unit tests serve as a safety net checking if the behavior of the implemented unit is (and stays) correct. As a side effect this will also find all type errors a compiler will find. I have programmed a lot in Java and also in dynamic programming languages and in my opinion type errors just don't happen often enough to justify the additional amount of work and complexity that comes with static type systems. However I'd agree that if you want to get the best possible performance you probably need a statically typed language as the compiler can then optimize the generated code better.

happy_dino 13y ago
> Java has no type inference, higher order functions, > coroutines, implicits (it has some standard implicit > conversions but not implicit conversions that can be > added by the user) and no Turing complete type system. Type inference in Java: int bar = new Object(){ int foo = 42; }.foo; // Magic? No. Type inference. Higher order functions in Java: http://download.java.net/jdk8/docs/api/java/util/stream/Stream.html Looks pretty higher-order to me. Also possible in older version in Java with stuff like Google Guava or FJ. Coroutines in Java: http://stackoverflow.com/questions/2846428/available-coroutine-libraries-in-java Implicits: Having them built into the language is even worse. In Scala you could just de-import them and have them gone. Anyway, pick C# as an example instead if you want to have user-defined implicit conversions. No Turing complete type system: interface Interface<T> {} class Bang<T> implements Interface<Interface<? super Bang<Bang<T>>>> { static void bang() { Interface<? super Bang<Byte>> bang = new Bang<Byte>(); } } Looks pretty undecidable to me. In a way, it is even worse than other languages: You are unable to tell whether the type checker will terminate in finite time (like some other languages), but don't get any additional expressivness in return (unlike those other languages). > As a side effect this will also find all type errors > a compiler will find. No, absolutely not. > I have programmed a lot in Java and also in dynamic > programming languages and in my opinion type errors > just don't happen often enough to justify the > additional amount of work and complexity that comes > with static type systems. This comment certainly explains a lot. You are suffering from the "I used Java and Java is statically typed and it sucks, therefore all statically typed languages have to suck" fallacy.
- qammm 13y ago
  It seems we have different definitions of what type inference, higher order functions and Turing completeness means. :-) Regarding coroutines in Java: I don't know if libraries using native continuation mechanisms or bytecode manipulations prove that Java (the language) has continuation support. :-) I don't have anything against Scala. In my very first message I even said that I see the odds for Scala winning higher than the odds for Clojure winning - because I already see some enterprise adoption of Scala. Although I see the probability of Scala winning quite low. As you noticed with Java 8 Java is already borrowing a lot of useful things from Scala. I am sure conservative corporate decision makers will see less and less reasons to switch to Scala as time passes by. Also I don't think that Java sucks. I was just making a point from personal productivity experience. Your experience might differ from that. If I have a function: def upcase(s: String): String... The compiler with its static type system can tell me if e. g. I am trying to call the upcase function with an Int argument. But in my experience something like that just does not happen very often. Most programmers are not so stupid that they try to fit a square peg in a round hole. ;-) A unit test can check if the returned string is really the upcase version of the input parameter. Plus if the programmer would really assume that he could upcase an Int it would just as well give the feedback that his assumption was wrong-like the compiler.