É certo que há alguma verdade na afirmação de que “Scala é difícil”, mas a curva de aprendizado vale o investimento. Alguns dos recursos mais complexos da linguagem ( Tuplas , Funções , Macros , para citar alguns) em última análise, torna mais fácil para o desenvolvedor escrever um código melhor e Aumentar o desempenho por programação em Scala. Francamente, somos programadores e, se não formos inteligentes o suficiente para aprender uma linguagem que tenha alguma complexidade, estamos no ramo errado.

Escada é uma linguagem JVM com segurança de tipos que incorpora programação orientada a objetos e funcional em uma linguagem extremamente concisa, lógica e extraordinariamente poderosa. Alguns podem se surpreender em saber que o Scala não é tão novo quanto pensavam, tendo sido introduzido pela primeira vez em 2003. No entanto, foi especialmente nos últimos anos que Scala começou a desenvolver uma sequência significativa . O que levanta a questão de “Por que Scala?”.

Este artigo examina as vantagens do Scala, especialmente em relação ao Java (uma vez que o Scala foi escrito para ser executado na JVM). Scala não é a única tentativa de criar um “Java melhor”. Alternativas como Kotlin e Ceilão também seguiram esse caminho, mas tomaram a decisão fundamental de permanecer muito próximos na sintaxe da própria linguagem Java, de modo a minimizar a curva de aprendizado. Pode parecer uma ótima ideia, mas, em última análise, é um tanto autodestrutiva, pois força você a permanecer dentro de alguns dos mesmos paradigmas Java que foram a razão para querer criar um “Java melhor” em primeiro lugar.

Em contraste, Scala foi criado especificamente com o objetivo de ser um melhor língua , eliminando aqueles aspectos do Java que considerava restritivos, tediosos demais ou frustrantes para o desenvolvedor. Como resultado, existem de fato distinções de código e mudanças de paradigma que podem tornar o aprendizado inicial da programação Scala um pouco mais difícil, mas o resultado é uma linguagem muito mais limpa e bem organizada que, em última análise, é mais fácil de usar e aumenta a produtividade.

Scala vs. Java: o que é realmente mais complexo?

Embora a simplicidade da linguagem Java tenha sido parte de seu sucesso, ironicamente, ela também contribuiu para sua complexidade. Claro, você pode escrever quase tudo em Java, mas as linhas de código necessárias para isso podem ser assustadoras. A programação em Scala, por outro lado, tem uma estrutura um pouco mais complexa. Mas se você puder escrever um um pouco mais complexo solteiro linha de código que substitui 20 linhas “mais simples” do Java, qual é realmente mais complexa?

A verdade é que Java geralmente é muito prolixo. No Scala, o compilador é incrivelmente inteligente, então isso evita que o desenvolvedor precise especificar explicitamente as coisas que o compilador pode inferir. Compare, por exemplo, este simples “Hello World!” programa em Java vs. Scala:

Hello World em Java:

public class HelloJava { public static void main(String[] args) { System.out.println('Hello World!'); } }

Hello World em Scala:

object HelloScala { def main(args: Array[String]): Unit = { println('Hello World!') } }

Embora não haja uma grande diferença entre as duas línguas aqui, Scala é menos prolixo, mesmo neste exemplo simples.

Para um exemplo mais prático, vamos dar uma olhada na criação de uma lista simples de Strings:

Java:

List list = new ArrayList(); list.add('1'); list.add('2'); list.add('3');

Escada:

val list = List('1', '2', '3')

Certamente, existem alguns truques em Java para encurtar um pouco o código, mas não no uso padrão.

Agora considere um caso em que temos uma lista de strings que são números, mas queremos converter essa lista em uma lista de inteiros:

Java:

List ints = new ArrayList(); for (String s : list) { ints.add(Integer.parseInt(s)); }

Escada:

val ints = list.map(s => s.toInt)

Graças às propriedades funcionais do Scala, essa conversão se torna extremamente simples.

Um exemplo de classe: Java vs. Scala

Vamos dar um passo adiante e comparar o bean / padrão Objeto Java simples e antigo (POJO) criação em Java e Scala.

redimensionar imagens em design móvel responsivo

Primeiro, a versão Java:

public class User { private String name; private List orders; public User() { orders = new ArrayList(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public List getOrders() { return orders; } public void setOrders(List orders) { this.orders = orders; } } public class Order { private int id; private List products; public Order() { products = new ArrayList(); } public int getId() { return id; } public void setId(int id) { this.id = id; } public List getProducts() { return products; } public void setProducts(List products) { this.products = products; } } public class Product { private int id; private String category; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getCategory() { return category; } public void setCategory(String category) { this.category = category; } }

Ufa. Código Lotta.

Agora a versão Scala:

class User { var name: String = _ var orders: List[Order] = Nil } class Order { var id: Int = _ var products: List[Product] = Nil } class Product { var id: Int = _ var category: String = _ }

Qual idioma dissemos ser mais complicado ?!

Estamos sendo justos?

Se você chegou até aqui e é um programador Java, pode estar pensando, a essa altura, que estou fazendo uma comparação injusta de código. Afinal, nada me impede de criar variáveis ​​públicas em Java e, em seguida, me livrar dos getters e setters.

No entanto, se você pensar no raciocínio por trás de getters e setters em Java, é especificamente para preparação para o futuro. Ou seja, se mais tarde você precisar adicionar alguma lógica para obter ou definir as variáveis, você terá que reescrever essas variáveis ​​públicas para usar métodos em vez disso (é por isso que o uso de getters e setters para começar é encorajado em Java ) No entanto, na programação Scala, esse não é o caso. Por causa do design da linguagem, a abstração permanece intacta sem a necessidade de getters e setters. Considere, por exemplo, este modificado User classe em Scala que lança um NullPointerException se você tentar definir o nome como nulo:

class User { private var _name: String = _ var orders: List[Order] = Nil def name = _name def name_=(name: String) = { if (name == null) { throw new NullPointerException('User.name cannot be null!') } _name = name }

E você ainda pode definir o nome assim:

user.name = 'John Doe'

Observe que isso elimina totalmente a necessidade de pré-configurar os acessadores de método.

Além disso, como Scala prefere imutabilidade, posso escrever isso em Scala de forma ainda mais concisa com classes de caso:

case class User(name: String, orders: List[Order]) case class Order(id: Int, products: List[Product]) case class Product(id: Int, category: String)

Muito louco quanto menos código eu tenho que escrever.

Levando o exemplo um pouco além

Agora, considere um cenário com as classes acima onde desejo adicionar um método pequeno e bacana no User classe que retorna uma lista de todos Products que o User encomendou:

No mundo prolixo de Java:

public List getProducts() { List products = new ArrayList(); for (Order order : orders) { products.addAll(order.getProducts()); } return products; }

Felizmente, java.util.List tem um addAll método, ou getProducts() teria sido ainda mais longo em Java.

No Scala, por outro lado, tudo o que precisamos é:

como compilar em c ++

def products = orders.flatMap(o => o.products)

Você pode ver o quão menor é a implementação da linguagem Scala. Sim, pode parecer mais complexo para o novato do Scala, mas uma vez que você realmente entenda completamente os conceitos por trás dele, o código do Scala parecerá muito mais simplista do que o código Java.

Vamos complicar um pouco mais aqui. E se quisermos apenas obter o Products dentro de um específico Category?

Nesse caso, não podemos aproveitar as vantagens do addAll método em java.util.List, então as coisas ficam mais feias em Java :

public List getProductsByCategory(String category) { List products = new ArrayList(); for (Order order : orders) { for (Product product : order.getProducts()) { if (category.equals(product.getCategory())) { products.add(product); } } } return products; }

Em Scala , no entanto, o código permanece bastante simples. Simplesmente usamos flatMap para combinar as listas de produtos de cada Order nivelado em uma única lista, filtramos para incluir apenas aqueles que correspondem à categoria:

def productsByCategory(category: String) = orders.flatMap(o => o.products).filter(p => p.category == category)

Dinâmico vs. estático

Certamente não houve escassez de novas linguagens nos últimos anos, mas enquanto quase todas as outras que surgiram recentemente são dinâmicas, o Scala é tipado estaticamente.

Como um desenvolvedor profissional - embora eu conheça e use muitas linguagens dinâmicas - é minha opinião que as verificações de tempo de compilação são incrivelmente importantes para escrever código sólido. Em uma linguagem dinâmica, você nunca pode ter certeza de que seu código está suficientemente livre de bugs e robusto até que você realmente o execute em uma ampla gama de cenários. Isso pode levar a defeitos potencialmente sérios no código que nunca são percebidos até que o código esteja em produção.

Embrulhar

Esperançosamente, este artigo compara Java vs. Scala o suficiente para lhe dar uma noção preliminar do poder e das capacidades do Scala e aguçar seu apetite para aprender a linguagem. Não só é uma ótima linguagem que pode tornar a programação menos tediosa e mais agradável, mas também está sendo usado por algumas das maiores empresas do mundo (LinkedIn, Twitter, FourSquare, The Guardian, para citar apenas alguns).

A popularidade e o uso do Scala estão aumentando rapidamente, conforme evidenciado pelo número cada vez maior de posições abertas para Desenvolvedores Scala . Se você ainda não fez isso, agora seria um bom momento para começar a surfar na onda e parar de perguntar 'Por que aprender Scala?'

Compreender o básico

O que é Scala?

Scala é uma linguagem de programação de alto nível poderosa que incorpora programação orientada a objetos e funcional. É uma linguagem de tipo seguro que depende do tempo de execução da JVM.

Para que é usado o Scala?

Muitas coisas, desde aprendizado de máquina até aplicativos da web. Como uma linguagem de uso geral de alto nível, Scala possui uma ampla gama de aplicações possíveis. Scala permite que os desenvolvedores façam bom uso dos recursos JVM padrão e bibliotecas Java.

Como aprender Scala e por onde devo começar?

Se você está pensando em mergulhar no Scala, ter experiência em Java obviamente ajudará e você não terá problemas para encontrar recursos de aprendizagem online. No entanto, se você não tiver experiência em Java, precisará aprender o básico. Familiaridade com linguagens de programação funcionais também ajudará.

Quais empresas usam Scala?

De acordo com relatos da mídia e declarações oficiais, o Scala está sendo usado por várias empresas de tecnologia, incluindo Netflix, Twitter, LinkedIn, AirBnB, AT&T, eBay e até Apple. Também é usado em finanças, por empresas como Bloomberg e UBS.

Por que Scala não é (muito) popular.

Nos últimos anos, o Scala perdeu parte de seu apelo, o que levou alguns a concluir que está em vias de extinção. Este é um assunto de grande debate. Embora seja verdade que algumas empresas de alto perfil o abandonaram, o Scala ainda está forte e mantém um grande número de seguidores.