I've been learning Scala recently, and it seems like a very very promising general purpose programming language. It has all the good functional programming features, terse syntax, it runs on JVM and interoperates with Java.
Some think it's the Next Big Language. Others aren't so sure.
Why do you think it is/isn't going to be the next big thing?
No, probably not (too alien, no big corporate backer, too hard for VB monkeys), but that doesn't make it an any less interesting combination of features.
I agree with DrPizza (btw, ironic name as Scala is a descendant of the "Pizza" programming language). The IntelliJ guys are implementing Scala support, and from what they've said the language really is as complicated to implement as it looks.
I expect that the complicated syntax, little corporate backing, and steep learning curve will keep it from gaining anywhere near the traction that the Java language has. I do like some of the ideas from it, though, and hope that someone can build a less complex, easier to learn language based upon some of its strengths.
Even if it never gets adopted hopefully it will have an indirect influence on other languages and language designers can learn from it and steal some good ideas. (Especially Java.)
I don't think it really matters if a language is the next big thing or not. And because of the Internet heterogeneous groups can form and coexist.
If you enjoy Scala, that's all that you need to know.
I think Scala makes a very interesting combination between functional programming and OOP, and having access to JVM libraries is a big bonus. But still, I don't like it because I found it too complicated to learn the edge-cases. F#/Ocaml has a better design if you want functional programming.
I am not so sure than scala will not be the next big thing. The language is a bit complex to learn but it's a succesfull mix between functional and imperative system, it's a very modern and powerfull language!
I have already heard that some company are using it as main language for production software. I personnaly believe than it just need some succesfull leader projects and/or companies to popularize the concept.
F#/OCaml are better functional languages and easier to learn.
Scala is too bizarre to become a mainstream language. It will sit by the waysides, with a few fervent zealots (much like LISP), while everybody else uses other tools.
Well, I don't know if Scala will be the next big thing, but it has some attributes that make it a good candidate.
For me, the next big thing will be the "multi-language paradigm", I mean it will become more frequent to see a project with different languages doing different things. Maybe its logic implemented in Groovy and its GUI in JavaFX, maybe the concurrent stuff with Scala, and a DSL implemented with JRuby or Jython.
Anyway, I hope that its strange syntax will not be an impediment because I like Scala a lot and, in my opinion, it's a superior language to Java in many aspects.
Scala is getting some early traction in some very interesting places - notably SAP (check out the ESME project from the SAP Community). It's certainly some ways from becoming mainstream, and it's certainly possible to write near-incomprehensible code, but the fact that it has instant access to all Java libraries is a big win. I have implemented search engine integration in Scala in just a few lines & annotations using the existing Java-based Compass library.
I am still in steep learning curve territory, but the Scala and lift developer communities are pretty open & friendly places. In some ways the complexity is a bonus - if I find another Scala coder, I know they're likely to be pretty good at what they do.
I've tried it, and although it had some nice things, some parts of the syntax were just plain scary, and many features seemed quite useless to me. It's not minimalistic enough for my taste, and I find the typing system annoying. I think there are better things out there.
Scala might not become the next big thing - lack of a corporate backer is, in my mind, the biggest reason. But the next big thing might have many of the features of Scala. So I think learning Scala is indeed a good thing.
The interesting thing about Scala is largely that its a functionally-influenced language which is very pragmatic, so essentially all of its features are there to make its use easier, rather than to prove some academic point. It essentially combines the terseness of dynamic languages with the safety and toolability of static ones, mostly successfully. The typesystem ends up with a few complications as a result of this combination, but for those who are consuming libraries, rather than writing them, this can usually be ignored.
I really like it, and I think it's a lot better placed than its "purer" functional cousins, such as OCaml, Haskell or F#, to take off, on technical merits at least. As for whether it'll be the "next big thing", nobody can really tell, and this thread shows a few good examples to the contrary of it taking off like that. On the other hand I think the movement of languages to target the "big" VMs and reuse their libraries may well make the "next big thing" argument pretty academic; hopefully you'll be able to use whatever you like with no loss of functionality soon enough.
Javascript is the next big language :)
In my opinion, to achieve popularity, a language has to be easy to learn. PHP and Java, for example, are popular for that reason.
If Scala ever becomes popular, it's certainly not going to be because it supports monads; it's going to be because it has good interoperability with Java and supposedly .NET as well (I haven't tried the msil compilation switch yet so I can't say much about it).
What about Erlang, Haskell and F#?
I don't ever see Haskell gaining wide spread adoption. However it is a very beautiful language to study for it's functional purity. Erlang strikes me as a more practical Haskell. With its combination of functional and imperative features combined with its robust mechanisms for distributed programming I can definetly see it being a language that gains popularity for its ability to handle highly distributed scenarios very well. One famous example of this is Facebook chat, where Erlang is used to power the chats. Erlangs background in telecomm has poised it to be uniquely suited for distributed problems.
F# I don't know enough about, but I'm already encountering it in job requirements. From this I garner what I think is writing on the wall. That now is the time to start understanding the functional way of programming. While it is definitely too early to tell what language will win the functional battle, I think that overall we can say that the functional paradigm is strongly gaining steam and those of us who like to think of ourselves as "Bleeding Edge" or at the top, need to understand the benefits that can be gained from functional programming. It will probably be a while before most of us are asked to build a solution in any of these languages, but if nothing else learning one of these languages will help you become a better programming in the imperative model.
I think that the question will not be which language to use but which framework to build on. There are many acceptable languages nowadays, so the real task is how to get them to interoperate as seamlessly as possible.
If you're a Java shop, Scala is a nice "next" language on the JVM. Calling Scala code in Java and back again is actually really quite direct, for the most part.
I just don't see the "Scala vs. F#" or "Scala vs. Haskell" comparisons, though. To me, those are different programming environments altogether.
And, I don't see people saying "Clojure is easier than Scala", because while Scala's syntax is funky, it's definitely not Lisp! Sorry, I just can't fathom the average code monkey sitting back and embracing an S-expression language.
Dynamic languages are also probably not going to take "over" a language like Scala. I'm more in the camp that a dynamic language like Ruby should actually be used alongside Scala. As in "extension" system. This is where I think things get really interesting, and the sort of thing I'd like to see adopted.
You can use Scala like Java... You'd need to forget about statics and emulate some things, but generally you can code Java in Scala. Even Scala's syntax can be similar to Java (just with the bits of Ruby... or other dynamic light language)
Scala can be much more than Java. You can gradually shift your way of coding towards immutable structures and higher order functions.
Being NGT doesn't mean being bigger than Java, C# or C++. It doesn't even mean stealing 1/10 of the mention languages market.
Scala's cool language features and uniqueness is interesting for hackers and passionate guys, but it's JVM compatibility and static typing will in the future mean a lot for corporate users.
The saturation of the programming language market with languages suggests that a new language better offer radically awesome things relative to other languages on the market. e.g.,
What does Scala offer that's radically awesome relative to F# or Lisp?
Knowing nothing about Scala, I can tell you that it's probably not the next big thing. The reason is that there are lots of contenders, and very few next big things.
There are some things that contribute to being the NBT:
There are things that don't. Academic considerations play no part, or C wouldn't have swamped Pascal. Being somewhat better isn't good enough.
There's also luck involved. IBM tried to make PL/I into the NBT, and the Department of Defense did the same with Ada. There were good reasons to expect Tcl to become the NBT.
Most languages will live on, but never become a Big Thing. There's hordes of languages that have excellent implementations, a thriving community, but never become stars. Sometimes features from them are adopted into other languages (much of modern language design has been adopting features from Lisp, for example).
Lemmings supposedly run off cliffs.
Programmers run after Next Big Things.
Meanwhile, as hardware gets bigger and faster, software gets bigger and slower.
What's going on here?
I do think functional languages are the next big thing, generally speaking. But in specifics, Lisp is still probably the next big thing. True that might be 2-20 years off. Scala might be an intermediate pretty-neat-thing-but-not-huge. Lisp is a multi-paradigm language - functional, imperative, object oriented, whatever you can think of and however you need to use it. Aspects are in fashion, hey you don't even need a "design pattern" for that in lisp . You just get it with the way it (Common Lisp, anyway) implements generic methods. If you need a DSL and need to change the way lisp does something, you can define your own language features as macros.
I still infinitely enjoy connecting to a remote, running lisp image and being able to modify the code without bringing the application down for any time at all.