views:

4715

answers:

21

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?

+9  A: 

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.

DrPizza
+1  A: 

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.

jsight
Not ironic - coincidental.
George Mauer
What's ironic is that if IntelliJ IDEA - a commercial product that is first and foremost done the way it's done to sell well - implements Scala support, it's a very good sign for Scala adoption.
Pavel Minaev
java also has a steep learning curve (to me at least)
rogerdpack
+5  A: 

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.)

Jared Updike
+13  A: 

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.

Alexandru Nedelcu
+2  A: 

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.

Steve Gury
+4  A: 

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.

FlySwat
I agree... they are a nice midpoint between purely functional and imperative. Have Objects and, in general, cater to all types of programing styles and techniques.
nlucaroni
This is pure opinion with no supporting evidence. Scala combines the practicality of Java with the expressiveness of a modern functional programming language. There are some concessions due to the requirement to run on the JVM, but pragmatic compromises didn't hurt C++ or Java's adoption.
sanity
Hey look, there's one of those zealots I was talking about :)
FlySwat
I think that this is a risk, but I also believe that the scala community is still young enough that the language is going to continue to change rapidly, and perhaps become less alien as good patterns emerge. The great benefit of Scala is that its integration with Java is excellent.
Kris Nuttycombe
I would disagree that, for someone with Java or C# background, F# is easier to learn than Scala. Scala offers more familiar syntax and gentler learning curve - you can naturally use it as "Java++", slowly grokking its unique features. With F#, you're immediately plunged into the world of entirely different (and strange!) syntactic constructs, as well as disturbing concepts such as global type inference. Ditto for OCaml, though that has a bigger problem due to the lack of a good framework to build upon, and quality library selection is fairly poor.
Pavel Minaev
-1, This is the most bizarre and senseless answer I have come across on SO.
missingfaktor
+39  A: 

Well, I don't know if Scala will be the next big thing, but it has some attributes that make it a good candidate.

  • Functional seems to be getting more and more important with the increment of multi-core architectures.
  • Runs over the JVM
  • It's object oriented.
  • Java/C++ syntax
  • XML as a language construct

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.

Alotor
+24  A: 

Scala is the next Haskell.

John the Statistician
I'm not sure how that was intended but I thought it was funny!
Jon Harrop
Thanks kindly, I'm sure you took it in the spirit it was intended
John the Statistician
My thoughts exactly!
Jarret Hardie
In what way? What are the similarities between the two, other than Scala having some functional language properties?
axel22
+6  A: 

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.

Darren Hague
You'll have to tear ABAP out of SAP's cold dead hands. SAP's embrace of Java is aloof at best. SAP guys are cool folks with fun ideas but if it ain't ABAP it doesn't go anywhere.
Xepoch
+2  A: 

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.

Dough
+6  A: 

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.

binil
+5  A: 

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.

Calum
+5  A: 

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).

Leo
Javascript is already huge. :)
abababa22
Javascript is huge because it's the only one in it's field. I don't see JS anywhere else.
Kugel
+5  A: 

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.

DanielHonig
+1  A: 

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.

Svante
+6  A: 

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.

Tristan Juricek
Actually Scala is pretty damn close to F# in the end, despite the philosophical differences. The amount of code you have to write in either to do the same thing is roughly equivalent and mostly uses the same concepts.
Pavel Minaev
+7  A: 
  1. 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)

  2. Scala can be much more than Java. You can gradually shift your way of coding towards immutable structures and higher order functions.

  3. 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.

  4. 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.

Szymon Jachim
+3  A: 

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.,

  • Ruby had Rails.
  • C# had full microsoft support and was an evolved Java-esque language.
  • F# has full Microsoft support and has access to .Net libs.
  • Java had portability.

What does Scala offer that's radically awesome relative to F# or Lisp?

Paul Nathan
If you ask LISP hackers, other languages are still catching up.
abababa22
Scala has access to Java libs, and it does have quite a few concepts that have no direct analog, or good workarounds, in either C# or F# - traits and mixins come to mind immediately.
Pavel Minaev
@Pavel: Java libs is good. Although I would like to point out that C++ supports both traits and mixins - but alas, that's my fanboy speaking.
Paul Nathan
+21  A: 

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:

  • Corporate backing (Java, C#)
  • A killer app written in it (like Unix for C)
  • Similarity to earlier Big Things (Java and C# benefit from similarity to C and C++)
  • Being clearly better than the last Big Thing (C's takeover of PCs from Pascal)
  • Filling a niche well that was not previously well served (Perl and scripting)
  • Being part of a new expanding field (PHP and the Web)
  • Fitting into existing tools (C++'s compatibility with C, new .NET languages)

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).

David Thornley
Corporate backing is a big deal. If someone (Google?) jumps on the Scala bandwagon, then it will be the next big thing, at least in Java ecosystem. If not, it will be an interesting project that'll get used mostly for toy projects by curious developers until the next "thing that's going to be the next big thing". Oh yes, and good tooling is a must, though Scala makes good advances there already.
Pavel Minaev
I would say the Twitter Backend could be considered a killer app
Helper Method
About your last point, it is a JVM language, and supposedly(I haven't tried it) using java libraries in scala and even vice versa is fairly easy.
Roman A. Taycher
+3  A: 

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?

Mike Dunlavey
+2  A: 

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.

The problem is that Lisp has been the next big thing for at least 30 years already, but it still isn't it. At the same time, you may notice that new mainstream languages slowly but steadily acquire the features that were once unique to Lisp (and then some that weren't even in it). Impure FP is effectively mainstream now with C# 3.0, VB9, Python, and Ruby. Metaprogramming is getting there - see Ruby, D. Multimethods will be coming eventually, I'm sure. The only thing that will remain to Lisp is Lots of Irritating Superfluous Parentheses ;)
Pavel Minaev