Neste artigo exploraremos em profundidade o tema Scala (linguagem de programação), seu impacto na sociedade atual e sua relevância em diferentes áreas. Ao longo da história, Scala (linguagem de programação) tem sido um tema de grande interesse e investigação, com múltiplas perspectivas e abordagens que têm contribuído para a compreensão e desenvolvimento de novas ideias. Desde a sua influência na economia, cultura e política, até ao seu impacto na vida quotidiana das pessoas, Scala (linguagem de programação) revelou-se uma questão multidimensional que merece ser analisada e discutida. Através de uma análise exaustiva, este artigo procurará fornecer uma visão clara e abrangente sobre Scala (linguagem de programação), oferecendo aos leitores uma compreensão mais profunda e significativa da sua importância hoje.
Scala | |
---|---|
Paradigma | |
Surgido em | 20 de janeiro de 2004 (20 anos) |
Última versão | 3.3.1 (9 de setembro de 2023) |
Criado por | Martin Odersky |
Estilo de tipagem |
|
Principais implementações | maven-scala-plugin |
Influenciada por | |
Influenciou | |
Licença: | BSD |
Extensão do arquivo: |
|
Página oficial | www |
Scala (Scalable language) é uma linguagem de programação de propósito geral, diga-se multiparadigma, projetada para expressar padrões de programação comuns de uma forma concisa, elegante e type-safe (é a medida em que uma linguagem de programação desestimula ou impede erros de tipo). Ela incorpora recursos de linguagens orientadas a objetos e funcionais. Também é plenamente interoperável com Java. Scala é a sucessora de Funnel, uma linguagem baseada em join calculus. Scala é software de código aberto. Requer JDK versão 1.4 ou superior. Scala é uma linguagem de programação relativamente nova. Mesmo assim, nos últimos anos, conquistou empresas gigantes como o Twitter e o Foursquare. Uma das primeiras diferenças entre Scala e uma linguagem como Java, é que Scala também suporta o paradigma funcional.
Scala foi desenvolvida em 2001 por Martin Odersky e pelo grupo dele na École Polytechnique Fédérale de Lausanne (EPFL), Lausana na Suíça.
Anteriormente, (1986-1989) Martin trabalhou como um estudante Ph.D. com Niklaus Wirth em ETH Zuerich como um estudante Ph.D. em Modula-2 e Oberon. Depois disso, ele trabalhou nos fundamentos da linguagem de programação e programação funcional.
Em 1995 ele se juntou com Philip Wadler para escrever uma linguagem de programação funcional que compila Java bytecode. Este trabalho no Pizza levou, eventualmente , para GJ, o novo compilador javac, e Java generics.
Em 1999, depois de se unir a EPFL, este trabalho mudou um pouco. A meta ainda era combinar programação orientada a objetos e programação funcional, mas sem as restrições impostas pela linguagem Java. O primeiro passo para este caminho era o Funnel, uma linguagem minimalista de busca baseada em redes funcionais, uma variante orientada a objetos de join calculus. Funnel era pura do ponto de vista de design de linguagem, com poucas características de linguagem primitiva. Quase tudo, incluindo classes e padrões correspondentes, seria feito por bibliotecas e codificações.
No entanto, foi descoberto que linguagem não era agradável para o uso na prática. Minimalismo era ótimo para desenvolvedores, mas não para usuários. Usuários não experientes não sabiam como fazer a codificação necessária, e usuários experientes ficavam entediados por ter as codificações repetitivamente. Também, se tornou claro que qualquer nova linguagem tem melhor chance de ser aceita com um amplo conjunto de bibliotecas padrões.
O segundo, e atual, é o Scala, que trouxe algumas das ideias do Funnel e colocou dentro de uma linguagem mais pragmática com foco especial no funcionamento com plataformas padrões. Scala não é uma extensão de Java, mas é completamente interoperável com ele. Scala traduz para Java bytecodes, e a eficiência de ele compilara programas normalmente iguais aos do Java. Uma segunda implementação de Scala compila .NET. O design do Scala começou em 2001. Um primeiro lançamento ao público foi em 2003. Em 2006, uma segunda, versão remodelada foi lançada como Scala v 2.0. Desde então a linguagem tem ganhado popularidade.
Em Janeiro de 2011, uma bolsa de pesquisa de cinco anos foi concedida ao grupo Scala, pelo Conselho Europeu de Investigação (CEI) com o valor total de €2,3 milhões. Já em Maio do mesmo ano, Odersky e seus colaboradores lançaram uma empresa, a Typesafe Inc. (posteriormente viria a ser chamada de Lightbend Inc.), a qual tinha como intuito fornecer à Scala suporte comercial, treinamento e serviços diversos. Isso só foi possível em decorrência do investimento que a Typesafe recebeu da Greylock Partners, no valor de $3 milhões.
Scala é similar a linguagem de programação Java, e roda na Java Virtual Machine, é compatível com programas java existentes. Uma implementação alternativa existe para a plataforma .NET, mas a plataforma base é mesmo para Java Scala é primariamente desenvolvida para a JVM e incorpora algumas de suas características. De qualquer forma, o suporte a .NET foi criado para deixá-la tão portátil entre duas plataformas o quanto possível. Scala ainda pode ser executada no Java Platform, Micro Edition Connected Limited Device Configuration.
A implementação em Scala é muito similar a usada em Java ou C. São utilizados os mesmos operadores e controles de estruturas bem similares.
Principais diferenças sintáticas:
A linguagem Scala importa por padrão todas as classes do pacote java.lang, enquanto que todas as outras podem ser importadas explicitamente. A biblioteca de classes Java define um amplo conjunto de classes utilitárias, como Date e DateFormat. Como Scala interage diretamente com Java, não existem classes equivalentes na biblioteca de classes Scala, então os pacotes são importados do Java.
Exemplo:
import java.util.{Date, Locale}
import java.text.DateFormat
import java.text.DateFormat._
object FrenchDate {
def main(args: Array) {
val now = new Date
val df = getDateInstance(LONG, Locale.FRANCE)
println(df format now)
}
}
Scala é puramente orientada-a-objetos no sentido de todo o valor ser um Objeto. Tipos e comportamento dos objetos são descritos pelas classes e traços. Abstrações de classes são estendidas por "subclassing" e um flexível mecanismo de "mixin-based composition" como uma forma "limpa" de substituição a heranças múltiplas.
Classes em Scala são templates estáticos que podem ser instanciados como vários objetos em tempo de execução.
Um exemplo de definição de uma classe Ponto:
class Ponto(var x: Int, var y: Int) {
def move(dx: Int, dy: Int): Unit = {
x = x + dx
y = y + dy
}
}
Podemos criar um objeto do tipo Ponto utilizando a palavra reservada new:
object Main {
def main(args: Array) {
val ponto = new Ponto(3, 5)
println("(" + ponto.x + ", " + ponto.y + ")")
ponto.move(10, 10)
println("(" + ponto.x + ", " + ponto.y + ")")
}
}
A saída gerada pelo programa é esta:
(3, 5)
(13, 15)
Scala é também uma linguagem funcional, no sentido de cada função ser um valor. Scala fornece uma sintaxe "leve" para definição de funções anônimas, ela suporta higher-order functions, ela permite que funções sejam aninhadas (funções são passadas como parâmetros dentro de outras funções, são tratadas como objetos), e suporta currying. Classes Scala e seu suporte interno para pattern matching modela tipos algébricos usados em muitas linguagens de programação funcionais. Além disso, sua noção de "pattern matching" natural é estendida para o processamento de arquivos XML com a ajuda de expressões regulares. Neste contexto, a linguagem se torna de grande valia para o processamento de sintaxes futuras. Estas características, fazem com que o Scala seja ideal para o desenvolvimento de aplicações como web services. Segue abaixo uma implementação do while loop que deve ser uma função que utiliza dois parâmetros: uma condição, de tipo booleano, e um comando , de tipo Unit. Ambas precisam ser passadas por nome, então elas são avaliadas repetidamente no loop de iteração:
def whileLoop(condition: => Boolean)(command: => Unit) {
if (condition) {
command; whileLoop(condition)(command)
} else ()
}
O Scala é equipado com um sistema de tipos expressivo, que reforça estaticamente que abstrações sejam usadas de maneira segura e coerente. Em particular, o sistema de tipos suporta:
O design do Scala, reconhece o fato de, na prática, o desenvolvimento de aplicações de domínio-específico requerem extensões a linguagens de domínio-específico. O Scala fornece uma combinação única de mecanismos de linguagem, que possibilitam a adição de construções na forma de bibliotecas, e com boa facilidade:
A junção das duas características, facilita a definição de novos "statements" sem estender a sintaxe e sem usar a mágica da metaprogramação.
Scala foi projetado para interoperar bem com ambientes de programação populares, tais como Java 2 Runtime Environment (JRE) e .NET CLR. Em particular, a interação com linguagens orientadas-a-objeto, Java e C# por exemplo, é a mais robusta quanto possível. Em outras palavras, Scala pode fazer uso de todas as bibliotecas disponíveis para Java/C#, endereçando o comum inconveniente de usar avançadas linguagens funcionais, em sua maioria centrada academicamente, frequentemente não oferecendo bibliotecas de muita qualidade, para uso prático, acesso a bancos de dados relacionais, processamento XML, expressões regulares, por exemplo. Scala pode realizar estas tarefas de uma maneira muito similar a qual é feita em Java ou C#. Scala tem o mesmo modelo de compilação (compilação separada, carregamento dinâmico de classe) de Java e C#.
Programa olá mundo
Aqui está o programa "Olá Mundo" escrito em Scala:
object OlaMundo {
def main(args: Array) {
println("Olá, Mundo!")
}
}
ou
object OlaMundo extends Application {
println("Olá, Mundo!")
}
Note como ele é bem similar com a sintaxe Java. A diferença mais notável é que não declaramos nada como static
ou void
; a palavra-chave object
nos dá o objeto Singleton, nos livrando da necessidade de invocar qualquer outro construtor.
A linha seguinte invoca o compilador, assumindo que foi salvo como OlaMundo.scala:
> scalac OlaMundo.scala
E executa desta maneira:
> scala -classpath . OlaMundo
A compilação e execução deste modelo é idêntica ao Java, fazendo com que as ferramentas de automação (build) sejam compatíveis, como o Ant.
Exemplo de IF
A condição IF sempre em ternários:
val x = 30
val y = 15
val maximo = if (x > y) x else y
maximo: Int = 30
Exemplo de FOR
O FOR pode retornar valor:
val lista = lista(1, 2, 3, 4)
val par = for {
i <- lista
if (i % 2 == 0)
} yield i
par: lista = lista(2, 4)
Formas para teste de códigos Scala:
Outro exemplo para estudo, números perfeitos:
object Numeros_Perfeitos {
def main(args: Array) = {
println("------NÚMEROS PERFEITOS------")
println("\nUm número se diz perfeito se eh igual a soma de seus divisores próprios." )
println("Divisores próprios de um número positivo N são todos os divisores inteiros")
println("positivos de N exceto o próprio N. ")
println("Por exemplo, o número 6, seus divisores próprios são 1, 2 e 3, cuja soma = 6. ")
println("--> 1 + 2 + 3 = 6 ")
println("Outro exemplo é o numero 28, cujos divisores próprios são 1, 2, 4, 7 e 14,")
println("e a soma dos seus divisores próprios é 28. ")
println("--> 1 + 2 + 4 + 7 + 14 = 28 ")
var cont, x, soma, t: Int=0
var n = 4 // n = ao número de números perfeitos que irão ser achados
println("\n\nPrograma mostra os 4 primeiros números perfeitos\n")
while (cont != n) {
x += 1
soma = 0
for (i <- 1 to x - 1) {
t = x % i
if(t == 0) {
soma += i
}
}
if (soma == x) {
println(x)
cont += 1
}
}
}
}
Akka
Akka é uma estrutura moderna middleware orientado a eventos, para a construção de alto desempenho e confiabilidade de aplicações distribuídas em Java e Scala. A lógica de negócios do Akka desacopla de baixo nível de mecanismos como threads e locks. A lógica de seu programa Scala ou Java vive em objetos ator leves que enviam e recebem mensagens. Com Akka, você pode facilmente configurar como os atores são criados, destruídos, programados e reiniciados após a falha.
Play framework!
Surgiu como um framework Java, que fornecia suporte a linguagem Scala. Mas reconhecendo o poder e produtividade da linguagem Scala, a versão 2.0 do framework foi totalmente re-escrita em Scala. Atualmente, o Play Framework! 2.0 é um framework Scala, com suporte a Java.
Uma das principais características desse framework é que ele foca no desenvolvimento de um "server-side stateless". Isso facilita a escalabilidade das aplicações desenvolvidas neste framework.
Assim como Interface em Java, existe em Scala um equivalente conhecido como mixin. Mixin é um mecanismo que incentiva o reuso de código e evita problemas causados pela herança múltipla.
Quando uma classe inclui um mixin, a classe implementa a interface e inclui, em vez de heranças, todos os atributos e métodos. Eles se tornam parte de uma classe durante a compilação . Mixins não precisam de uma interface implementada. A vantagem de implementar uma interface é que em linguagens estaticamente tipadas, instancias da classe podem ser passadas como parâmetros para métodos que necessitam daquela interface.
Outras linguagens que utilizam mixin: