Will Java 8 Kill Scala?

This is an expansion of my HN comment In response to a comment by HN user justinsb on HN about this article of the same title

The original comment (by HN user justinsb): #

It isn’t that Java 8 will kill Scala, it is that Scala has demonstrated the utility of lambdas to the point where they can safely be incorporated back into Java. So Scala has “won”, but in my opinion likely Scala will now fade away. Java is necessarily very conservative with adopting language features, because it is very careful to maintain backwards compatibility. Java is a bit like Debian stable - out of date compared to Debian testing or even other distros - but solid as a rock. For features to make it into Java, they really need to be proved first in other languages or in external libraries.
This isn’t the first time Odersky has advanced Java either - he worked on Pizza, which showed how to add Generics to Java. Scala demonstrates how to add functional features to Java. Generics were a huge advance, and I think lambdas will be as consequential.
So if Scala does die, it will be as a sacrificial lamb, rather than as a casualty of an unseen war.

My reply (enhanced with examples) #

As a Scala and Java developer, I am not even slightly tempted to replace Scala as my main language for my next project with Java 8.

If I’m forced to write Java, it might better be Java 8, but if I have a choice, there are so many things (as the OP correctly states) that make Scala compelling for me beyond Lambdas that just adding that feature to Java doesn’t really mean anything to me. Ruby has Lambdas, so does Python and JavaScript, Dart and I’m sure any other modern language. I like Scala because of so many other things other than lambdas that a single comment is not enough.

But to name a few (some were referenced by the OP)

val x = try { ... } catch { ... }
val y = if(...) else ...
val z = for(...) yield {...}
//pseudo REST API... don't be alarmed
val result = for { 
  //returns a future 
  response <- request("some/rest/api") 
  //just a regular variable 
  someField = response.toJSON.find("some.property") 
  if someField == "someExpectedValue"
  request2Body = s"{someField: $someField}"
  //returns a future
  response2 <- request("other/rest/api", request2Body)
  //and so on
} yield { 
  //do something with response2

result match { 
  case Success(actualResult) => //do something with the result
  case Failure(x) => //x is any throwable thrown along the way

//"add" a new method to java.io.File

implicit class RichFile(val file: File) extends AnyVal {
  def unzip(newFolder: File) = ZipUtil.unpack(file, newFolder)
//One line in scala
case class Person(name:String, age:Int)
//is doing the same as 61 lines in Java

public class Person {

  private String name;
  private Integer age;

  public Person(String name, Integer age) {
    this.name = name;
    this.age = age;

  public static Person apply(String name, Integer age) {
    return new Person(name, age);

  public void copy(Person p) {

  public String getName() {
    return name;

  public void setName(String name) {
    this.name = name;

  public Integer getAge() {
    return age;

  public void setAge(Integer age) {
    this.age = age;

  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    if (age != null ? !age.equals(person.age) : person.age != null) return false;
    if (name != null ? !name.equals(person.name) : person.name != null) return false;
    return true;

  public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + (age != null ? age.hashCode() : 0);
    return result;

  public String toString() {
    final StringBuilder sb = new StringBuilder("Person{");
    sb.append(", age=").append(age);
    return sb.toString();

def eval(expression : Expression, xValue : Int) : Int = expression match {
  case X() => xValue
  case Const(cst) => cst
  case Add(left, right) => eval(left, xValue) + eval(right, xValue)
  case Mult(left, right) => eval(left, xValue) * eval(right, xValue)
  case Neg(expr) => - eval(expr, xValue)
val pair = ("apples", 3)
val (fruit, num) = pair
val cityPopulation = Map(
  ("US", "GA", "Rome") -> 36303,
  ("Italy", "Rome") -> 2753000

cityPopulation.get(("Italy", "Rome"))
cityPopulation.get(("US", "GA", "Rome"))
val x = "variables"
s"I can embed $x in code!"

val justPaste = """
put here
anything you want 
including " or ' 
def foo(x:String = "", y:Int = 0, z:Boolean = true) = ...
foo(z = false, y = 3)

And many more:

Yes, compile times are worse, but I can live with it, and binary compatibility is still a big issue, but somehow it doesn’t amount to causing me to ditch Scala in favor of anything else at this time.

I think Scala is here to stay, at least for Scala developers, I am 100% sure you will not find a single Scala developer that will say: “Java 8 got lambdas? great, goodbye Scala forever!”.

The only reason I can think of is compile time and binary compatibility. If we ignore these two, all I can say is that this just proves how Scala is in the right direction (since Java 8 lambdas and default interface methods and steams are so clearly influenced)

I do wish however that Scala will improve Java 8 interoperability, e.g. support functional interfaces the same way and add new implicit conversions to Java 8 collections as well as take advantage to improvements in the JVM.

I will replace Scala as soon as I find a language that gives me what Scala does and does it better. So far I didn’t find such a language (examined Haskell, Clojure, Go, Kotlin, Ceylon, Dart, TypeScript, Rust, Julia, D and Nimrod, Ruby Python, JavaScript and C#, some of them were very promising but since I need a JVM language, and preferably a statically typed one, it narrowed down the choices pretty quickly)

Java 8 is even close, sorry. Great improvement, I’m very happy for Java developers that will get “permission” to use it (might be easier to adopt than Scala in an enterprise) but this is not a reason for a Scala shop to consider moving back to Java.


Now read this

Why Java Is Still Relevant

Or why it’s not a bad idea learning it even if you hate it (migrated from https://medium.com/i-m-h-o/da3b2c180e9c) Java is probably one of the most “love to hate” languages out there. According to this HN poll it is the 2nd most hated... Continue →