Por que usar o Scala sobre Java

Eu gosto muito do Scala como uma linguagem ... e ainda luto com o motivo pelo qual qualquer empresa deve mudar do Java para o Scala. O Scala é apenas açúcar sintático no topo da JVM ou há melhorias fundamentais no Scala sobre Java que melhorariam os aplicativos do mundo real?

Disclaimer: Eu não sou um guru do Scala.

Scala faz duas coisas extremamente bem que Java (atualmente) não faz.

Resolver problemas funcionais

• No nível mais básico, a Scala possui fechamentos completos com suporte a coleções. Isso significa que você não precisa mais escrever um código de placa da caldeira, como (descaradamente arrancado de um post do DZone)

  public List<Item> bought(User user)
  {
      List<Item> result = new ArrayList();
      for (Item item : currentItems)
      {
          if (user.bought(item))
          {
              result.add(item);
          }
      }
      return result;
  }

Mas, em vez disso, escreva algo como:

def bought(user: User) = items.filter(user bought _)

• Há um amor mais funcional, mas não estou qualificado para falar sobre isso, porque atualmente ainda sou péssimo em programação funcional :)

Resolva a simultaneidade de maneira mais segura

• O Scala tem um modelo de atores (+ alguma outra bondade) que é inerentemente mais seguro que os dados mutáveis ​​do Java + bloqueia no modelo Thread (não importa o quão boas as bibliotecas estejam ficando, o Java ainda é prejudicado pela linguagem).

Honestamente, não consigo pensar em mais nada que faça Scala ficar de cabeça e ombros acima de Java. Sim, muitos pequenos ganhos e melhorias, mas também muito mais corda para se pendurar. YMMV

HTH um pouco

Isso depende da sua definição de "apenas açúcar sintático". Por exemplo, de que maneira o Java é mais do que apenas açúcar sintático sobre código de máquina?

Qualquer idioma pode fazer menos que o código da máquina, mas nenhum idioma pode fazer mais.

O que as linguagens de alto nível trazem para a tabela é tornar o código mais fácil de ler e entender, mais fácil de compor e detectar mais erros. E, na minha opinião, é o primeiro deles que faz mais diferença - precisamente "apenas açúcar sintático".

Mas considerando apenas os outros dois, ainda existem vantagens do Scala sobre o Java.

Não insistir no assunto, mas ter fechamentos torna o código muito mais fácil de compor do que não ter fechamentos. E embora o Java 7 adicione algo chamado encerramento, eles não serão assim - serão apenas funções anônimas.

Quanto à detecção de mais erros, o manuseio superior da variação da Scala é uma prova suficiente. Além disso, sua ênfase na imutabilidade também evita todos os tipos de erros - não é que o Java não possa ser imutável, mas simplesmente não vem com a biblioteca para fazer isso.

Além da resposta de Martijn, gostaria de acrescentar que o Scala é mais expressivo que o Java e os benefícios são que: (1) torna você mais produtivo (2) escrever menos código para resolver o mesmo problema significa que você pode reduzir os bugs no seu código (código livre de erros IMHO é um mito).

Estou usando o Scala há cerca de 3 meses e ainda não consigo encontrar nada que não pudesse fazer em Java. Para mim, literalmente, cada literatura sobre Scala parece mencionar a mesma coisa clichê . Se o que você está procurando é reduzir o clichê, então o Scala é para você, mas IMHO, por exemplo, o exemplo de filtro fornecido acima também pode ser resolvido usando coleções do apache

<T> CollectionUtils.filter(Predicate<T>...)

ou usar tampas como assim

<T> CollectionUtils.forAllDo(..., Closure<T>)

Mas é claro que é mais detalhado. Eu gosto da inferência de tipo. Ao aprender Scala, você perceberá que é provavelmente o que está acontecendo de qualquer maneira. Na minha opinião, cada idioma vem com + ve e -ve.

compreensão de lista, para compreensão.

por exemplo, em java, você escreve:

int myVar;
if (condition) {
  myVar = //some value
}
else {
 myVar = //some other value
}

Em scala, o mesmo código, é muito mais elegantemente escrito (como python) como:

int myVar = (//some value) if (condition) else // other value;

E feito.

Há tanta coisa que o Scala oferece que o Java não. Simplesmente não há comparação. O único problema é que as pessoas estão mais familiarizadas com Java (b / c é o que ensinam nas aulas de CS) e ainda não são tão habilidosas com o paradigma Scala.

Scala tem recursão de cauda, ​​pode retornar tuplas (algo que pode estar chegando no Java 8, eu acho).

Não é uma comparação. O Scala foi desenvolvido por Martin Ordersky, que trabalhou na equipe principal de Java Generics.

Scala é apenas uma linguagem muito superior. É tudo o que há para isso. As pessoas que dizem o contrário simplesmente não exploraram Scala o suficiente para conhecer melhor.

Acima, eu quis dizer otimização de recursão de cauda (que a JVM não pode fazer da maneira que o compilador da Scala).

O Scala também compila e executa mais rapidamente que os aplicativos JVM (Sim, é verdade). Sem mencionar as estruturas. Usamos o Tomcat, por exemplo, e implantamos algumas servelets para manipular o REST.

Uma coisa que o Tomcat não pode fazer são as operações assíncronas que requerem E / S sem bloqueio. Para isso, os desenvolvedores de JAVA normalmente inventaram uma solução alternativa usando uma fila de mensagens (envie a mensagem para a fila, e algum outro processo ou thread a pega e faz o que quiser em segundo plano).

Infelizmente, esse método é cr * p, e um hack sobre as limitações da implantação de servlets Java no Tomcat.

Vá conferir akka + spray. Ele usa os atores da scala (os atores são exatamente como os Threads, exceto que a única maneira de se comunicar é através de mensagens).

E pronto, as chamadas REST assíncronas são fáceis. Tarefa em segundo plano de longa execução? Sem problemas. Basta acionar e esquecer e fazer algumas pesquisas REST para verificar seu status no front-end de vez em quando.

Se você ainda está usando Java e acha que é melhor que o scala, é melhor parar de usar o computador para digitar e voltar aos dias das canetas de pena e escrever à luz de velas. Java é basicamente antediluviano em comparação com Scala.