b'\n_START_ARTICLE_\nScala (linguagem de programa\xc3\xa7\xc3\xa3o)\n_START_SECTION_\nHist\xc3\xb3ria\n_START_PARAGRAPH_\nScala foi desenvolvida em 2001 por Martin Odersky e pelo grupo dele na \xc3\x89cole Polytechnique F\xc3\xa9d\xc3\xa9rale de Lausanne (EPFL), Lausana na Su\xc3\xad\xc3\xa7a._NEWLINE_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\xc3\xa7\xc3\xa3o e programa\xc3\xa7\xc3\xa3o funcional._NEWLINE_Em 1995 ele se juntou com Philip Wadler para escrever uma linguagem de programa\xc3\xa7\xc3\xa3o funcional que compila Java bytecode. Este trabalho no Pizza levou, eventualmente , para  GJ, o novo compilador javac, e Java generics._NEWLINE_Em 1999, depois de se unir a EPFL, este trabalho mudou um pouco. A meta ainda era combinar programa\xc3\xa7\xc3\xa3o orientada a objetos e programa\xc3\xa7\xc3\xa3o funcional, mas sem as restri\xc3\xa7\xc3\xb5es 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\xc3\xadsticas de linguagem primitiva. Quase tudo, incluindo classes e padr\xc3\xb5es correspondentes, seria feito por bibliotecas e codifica\xc3\xa7\xc3\xb5es._NEWLINE_No entanto, foi descoberto que linguagem n\xc3\xa3o era agrad\xc3\xa1vel para o uso na pr\xc3\xa1tica. Minimalismo era \xc3\xb3timo para desenvolvedores, mas n\xc3\xa3o para usu\xc3\xa1rios. Usu\xc3\xa1rios n\xc3\xa3o experientes n\xc3\xa3o sabiam como fazer a codifica\xc3\xa7\xc3\xa3o necess\xc3\xa1ria, e usu\xc3\xa1rios experientes ficavam entediados por ter as codifica\xc3\xa7\xc3\xb5es repetitivamente.  Tamb\xc3\xa9m,  se tornou claro que qualquer nova linguagem tem melhor chance de ser aceita com um amplo conjunto de bibliotecas padr\xc3\xb5es._NEWLINE_O segundo, e atual, \xc3\xa9 o Scala, que trouxe algumas das ideias do Funnel e colocou dentro de uma linguagem mais pragm\xc3\xa1tica com foco especial no funcionamento com plataformas padr\xc3\xb5es. Scala n\xc3\xa3o \xc3\xa9 uma extens\xc3\xa3o de Java, mas \xc3\xa9 completamente interoper\xc3\xa1vel  com ele. Scala traduz para Java bytecodes, e a efici\xc3\xaancia de ele compilara programas normalmente iguais aos do Java.  Uma segunda implementa\xc3\xa7\xc3\xa3o de Scala compila .NET.  O design do Scala come\xc3\xa7ou em 2001. Um primeiro lan\xc3\xa7amento ao p\xc3\xbablico foi em 2003. Em 2006, uma segunda, vers\xc3\xa3o remodelada foi lan\xc3\xa7ada como Scala v 2.0. Desde ent\xc3\xa3o a linguagem tem ganhado popularidade._NEWLINE_Em Janeiro de 2011, uma bolsa de pesquisa de cinco anos foi concedida ao grupo Scala, pelo Conselho Europeu de Investiga\xc3\xa7\xc3\xa3o (CEI) com o valor total de \xe2\x82\xac2,3 milh\xc3\xb5es. J\xc3\xa1 em Maio do mesmo ano, Odersky e seus colaboradores lan\xc3\xa7aram uma empresa, a Typesafe Inc. (posteriormente viria a ser chamada de Lightbend Inc.), a qual tinha como intuito fornecer \xc3\xa0 Scala suporte comercial, treinamento e servi\xc3\xa7os diversos. Isso s\xc3\xb3 foi poss\xc3\xadvel em decorr\xc3\xaancia do investimento que a Typesafe recebeu da Greylock Partners, no valor de $3 milh\xc3\xb5es.\n_START_SECTION_\nOrienta\xc3\xa7\xc3\xa3o a objetos\n_START_PARAGRAPH_\nScala \xc3\xa9 puramente orientada-a-objetos no sentido de todo o valor ser um Objeto. Tipos e comportamento dos objetos s\xc3\xa3o descritos pelas classes e tra\xc3\xa7os. Abstra\xc3\xa7\xc3\xb5es de classes s\xc3\xa3o estendidas por "subclassing" e um flex\xc3\xadvel mecanismo de "mixin-based composition" como uma forma "limpa" de substitui\xc3\xa7\xc3\xa3o a heran\xc3\xa7as m\xc3\xbaltiplas._NEWLINE_Classes em Scala s\xc3\xa3o templates est\xc3\xa1ticos que podem ser instanciados como v\xc3\xa1rios objetos em tempo de execu\xc3\xa7\xc3\xa3o. _NEWLINE__NEWLINE_Um exemplo de defini\xc3\xa7\xc3\xa3o de uma classe Ponto:_NEWLINE_1 class Ponto(var x: Int, var y: Int) {2   def move(dx: Int, dy: Int): Unit = {3     x = x + dx4     y = y + dy5   }6 }_NEWLINE_Podemos criar um objeto do tipo Ponto utilizando a palavra reservada new:_NEWLINE_1 object Main {2   def main(args: Array[String]) {3     val ponto = new Ponto(3, 5)4     println("(" + ponto.x + ", " + ponto.y + ")")5     _NEWLINE_6     ponto.move(10, 10)7     println("(" + ponto.x + ", " + ponto.y + ")")8   }9 }_NEWLINE_A sa\xc3\xadda gerada pelo programa \xc3\xa9 esta:_NEWLINE_1 (3, 5)2 (13, 15)\n_START_SECTION_\nPrograma\xc3\xa7\xc3\xa3o funcional\n_START_PARAGRAPH_\nScala \xc3\xa9 tamb\xc3\xa9m uma linguagem funcional, no sentido de cada fun\xc3\xa7\xc3\xa3o ser um valor. Scala fornece uma sintaxe "leve" para defini\xc3\xa7\xc3\xa3o de fun\xc3\xa7\xc3\xb5es an\xc3\xb4nimas, ela suporta higher-order functions, ela permite que fun\xc3\xa7\xc3\xb5es sejam aninhadas (fun\xc3\xa7\xc3\xb5es s\xc3\xa3o passadas como par\xc3\xa2metros dentro de outras fun\xc3\xa7\xc3\xb5es, s\xc3\xa3o tratadas como objetos), e suporta currying. Classes Scala e seu suporte interno para pattern matching modela tipos alg\xc3\xa9bricos usados em muitas linguagens de programa\xc3\xa7\xc3\xa3o funcionais. Al\xc3\xa9m disso, sua no\xc3\xa7\xc3\xa3o de "pattern matching" natural \xc3\xa9 estendida para o processamento de arquivos XML com a ajuda de express\xc3\xb5es regulares. Neste contexto, a linguagem se torna de grande valia para o processamento de sintaxes futuras. Estas caracter\xc3\xadsticas, fazem com que o Scala seja ideal para o desenvolvimento de aplica\xc3\xa7\xc3\xb5es como web services. Segue abaixo uma implementa\xc3\xa7\xc3\xa3o do while loop que deve ser uma fun\xc3\xa7\xc3\xa3o que utiliza dois par\xc3\xa2metros: uma condi\xc3\xa7\xc3\xa3o, de  tipo booleano, e um comando , de tipo Unit. Ambas precisam ser passadas por nome, ent\xc3\xa3o elas s\xc3\xa3o avaliadas repetidamente no loop de itera\xc3\xa7\xc3\xa3o:_NEWLINE_def whileLoop(condition: => Boolean)(command: => Unit) {_NEWLINE_  if (condition) {_NEWLINE_    command; whileLoop(condition)(command)_NEWLINE_  } else ()}\n_START_SECTION_\nIndepend\xc3\xaancia de plataforma\n_START_PARAGRAPH_\nScala foi projetado para interoperar bem com ambientes de programa\xc3\xa7\xc3\xa3o populares, tais como Java 2 Runtime Environment (JRE) e .NET CLR. Em particular, a intera\xc3\xa7\xc3\xa3o com linguagens orientadas-a-objeto, Java e C# por exemplo, \xc3\xa9 a mais robusta quanto poss\xc3\xadvel._NEWLINE_Em outras palavras, Scala pode fazer uso de todas as bibliotecas dispon\xc3\xadveis para Java/C#, endere\xc3\xa7ando o comum inconveniente de usar avan\xc3\xa7adas linguagens funcionais, em sua maioria centrada academicamente, frequentemente n\xc3\xa3o oferecendo bibliotecas de muita qualidade, para uso pr\xc3\xa1tico, acesso a bancos de dados relacionais, processamento XML, express\xc3\xb5es regulares, por exemplo. Scala pode realizar estas tarefas de uma maneira muito similar a qual \xc3\xa9 feita em Java ou C#._NEWLINE_Scala tem o mesmo modelo de compila\xc3\xa7\xc3\xa3o (compila\xc3\xa7\xc3\xa3o separada, carregamento din\xc3\xa2mico de classe) de Java e C#.\n_START_SECTION_\nExemplos de sintaxe\n_START_PARAGRAPH_\nPrograma ol\xc3\xa1 mundo_NEWLINE_Aqui est\xc3\xa1 o programa "Ol\xc3\xa1 Mundo" escrito em Scala:_NEWLINE_object OlaMundo {_NEWLINE_  def main(args: Array[String]) {_NEWLINE_    println("Ol\xc3\xa1, Mundo!")_NEWLINE_  }}_NEWLINE_ou_NEWLINE_object OlaMundo extends Application {_NEWLINE_  println("Ol\xc3\xa1, Mundo!")}_NEWLINE_Note como ele \xc3\xa9 bem similar com a sintaxe Java. A diferen\xc3\xa7a mais not\xc3\xa1vel \xc3\xa9 que n\xc3\xa3o declaramos nada como static ou void; a palavra-chave object nos d\xc3\xa1 o objeto Singleton, nos livrando da necessidade de invocar qualquer outro construtor._NEWLINE_A linha seguinte invoca o compilador, assumindo que foi salvo como OlaMundo.scala:_NEWLINE_> scalac OlaMundo.scala_NEWLINE_E executa desta maneira:_NEWLINE_> scala -classpath . OlaMundo_NEWLINE_A compila\xc3\xa7\xc3\xa3o e execu\xc3\xa7\xc3\xa3o deste modelo \xc3\xa9 id\xc3\xaantica ao Java, fazendo com que as ferramentas de automa\xc3\xa7\xc3\xa3o (build) sejam compat\xc3\xadveis, como o Ant._NEWLINE_Exemplo de IF_NEWLINE_A condi\xc3\xa7\xc3\xa3o IF sempre em tern\xc3\xa1rios:_NEWLINE_val x = 30val y = 15val maximo = if (x > y) x else ymaximo: Int = 30_NEWLINE_Exemplo de FOR_NEWLINE_O FOR pode retornar valor:_NEWLINE_val lista = lista(1, 2, 3, 4)val par = for {_NEWLINE_  i <- lista_NEWLINE_  if (i % 2 == 0)} yield ipar: lista[Int] = lista(2, 4)\n_START_SECTION_\nFrameworks\n_START_PARAGRAPH_\nAkka_NEWLINE_Akka \xc3\xa9 uma estrutura moderna middleware orientado a eventos, para a constru\xc3\xa7\xc3\xa3o de alto desempenho e confiabilidade de aplica\xc3\xa7\xc3\xb5es distribu\xc3\xaddas em Java e Scala. A l\xc3\xb3gica de neg\xc3\xb3cios do Akka desacopla de baixo n\xc3\xadvel de mecanismos como threads e locks. A l\xc3\xb3gica de seu programa Scala ou Java vive em objetos ator leves que enviam e recebem mensagens. Com Akka, voc\xc3\xaa pode facilmente configurar como os atores s\xc3\xa3o criados, destru\xc3\xaddos, programados e reiniciados ap\xc3\xb3s a falha._NEWLINE_Play framework!_NEWLINE_Surgiu como um framework Java, que fornecia suporte a linguagem Scala. Mas reconhecendo o poder e produtividade da_NEWLINE_linguagem Scala, a vers\xc3\xa3o 2.0 do framework foi totalmente re-escrita em Scala. Atualmente, o Play Framework! 2.0 \xc3\xa9 um framework Scala, com suporte a Java._NEWLINE_Uma das principais caracter\xc3\xadsticas desse framework \xc3\xa9 que ele foca no desenvolvimento de um "server-side_NEWLINE_stateless". Isso facilita a escalabilidade das aplica\xc3\xa7\xc3\xb5es desenvolvidas neste framework.'