scala java7
TRANSCRIPT
Scala: Programação OO, Funcional e Concorrentena JVM
Andrei de Araújo Formiga
Universidade Federal da Paraíba
@andreiformiga
Scala?
Scala?
Scala?
Scala
O Que Veremos
• A Linguagem Scala
• OO e Funcional: Paralelos e Diferenças
• Programação Concorrente com Atores
Sobre Você
• Familiaridade com Orientação a Objetos
• Sabe Java (de preferência)
• Não necessariamente sabe prog. funcional
Scala
• Scalable Abstractions
• Martin Odersky, 2001
• Versão atual: 2.9 (maio)
• École Polytechnique Féderale de Lausanne
• Typesafe, Inc.
Histórico
• Pizza, Generic Java (1998)
• Java Generics (Java 5, 2004)
• Scala (2001)
OO + Funcional
• Classes, herança, encapsulamento (Java)
• Funções de 1a classe, Closures
• Pattern matching, objetos imutáveis
• Tipos paramétricos (generics)
Paradigmas
• Paradigmas mudam como resposta a
momentos de crise
• OO: “Crise do Software” da década de 70
• Atualmente: “crise da concorrência”
A Crise do Software
• Década de 1970
• Grandes Avanços na Eng. de Hardware
• Por que não em Software?
OO como Solução
• Simula, Smalltalk, C++
• Reuso!
• Componentes de Software!
• Problema resolvido?
Atualmente
Crise da Concorrência
• Processadores com mais núcleos
• É preciso aproveitar a capacidade
• Concorrência + mem. compartilhada = locks
Programação Funcional
• Início: Lisp (1959)
• Décadas de pesquisa em linguagens
• Estruturas imutáveis
• Vantagens: Concorrência, DSLs
Paralelos
FunçãoDados
Por que Scala?
• Java melhor que Java
• Expressividade + Eficiência
• JVM, bibliotecas Java
Por que Scala?
// Java
boolean nameHasUpperCase = false;
for (int i=0; i < name.length(); ++i) {
if (Character.isUpperCase(name.charAt(i)))
{
nameHasUpperCase = true;
break;
}
}
// Scala
val nameHasUpperCase = name.exists(_.isUpper)
Por que Scala?
Hello, World!
object Hello {
def main(args: Array[String]) {
println("Hello, world!")
}
}
objeto singleton
retorno Unit (implícito)
Classes, Métodosabstract class Shape {
protected var x: Int = 0
protected var y: Int = 0
def draw(): Unit
}
class Circle extends Shape {
private var r: Int = 0
override def draw() {
// desenha circulo
}
}
Construtores
abstract class Shape(x:Int, y:Int) {
def draw(): Unit
}
class Circle(x:Int, y:Int, r:Int)
extends Shape(x,y)
{
override def draw() {
// desenha circulo
}
}
Inferência de Tipos
class Tipos {
private var i = 0
private var c = 'X'
private var s = "Hello, world!"
private var f = 3.1415926535
private var b = true
}
Atalhos Sintáticos
• Chamada com 1 parâmetro pode omitir ()
• O ponto entre objeto e método é opcional
conta.deposito 1000
conta deposito 1000
Operadores
• Operadores são métodos
• É possível definir operadores arbitrários
2 + 3 = 2.+(3)
var v1 = new Vector2d(1.2, 4.5)
var v2 = new Vector2d(1.3, 2.7)
var v3 = v1 + v2
Variáveis que Não Variam
• Ênfase em objetos imutáveis
class Ponto {
private val x = 0
private val y = 0
def trans(dx: Int, dy: Int) = …
}
Atualizações Não-Destrutivas
class Ponto(x: Int, y: Int) {
def trans(dx: Int, dy: Int) =
new Ponto(x+dx, y+dy)
}
class Ponto(x: Int, y: Int) {
def trans(dx: Int, dy: Int) = {
val nx = x+dx
val ny = y+dy
new Ponto(nx, ny)
}
Funções e Closures
• Funções de 1a Classe
• Closures
(x: Int) => x + 1
def criaSomador(s: Int) =
(x) => x + s
Coleções
• Tuplas
• Listas, Arrays, mapas, conjuntos, etc
• Mutáveis e imutáveis
(2, “Hello, world!”)
Listas e Pattern Matchingobject Tamanho {
def tam(l: List[Int]): Int =
l match {
case Nil => 0
case x :: rl => 1 + tam(rl)
}
def main(args: Array[String]) {
val l1 = List(1, 2, 3, 4)
println(tam(l1))
}
}
Case Classes
• Classes “simples”
• Úteis para guardar dados
• Podem ser usadas com pattern matching
Case Classes
abstract class Ponto
case class Ponto2d(x: Int, y: Int)
extends Ponto
case class Ponto3d(x: Int, y: Int, z: Int)
extends Ponto
def processa(p: Ponto) =
p match {
case Ponto2d(x, y) => // usa x e y
case Ponto3d(x, y, z) => // usa x, y e z
}
Modelo de Atores
• Carl Hewitt et al. (MIT, 1973)
• Atores isolados que trocam mensagens
• Erlang
Atores em Scala
• scala.actor
– Biblioteca padrão
– Distribuída com a linguagem
– Razoavelmente madura
– Manutenção lenta
Atores em Scala
• Akka
– Biblioteca geral para concorrência
– Madura e estável
– Aplicações comerciais
– Bem mantida
– Atores remotos
Exemplo em Akka
Para Saber Mais
• www.scala-lang.org
• www.typesafe.com
• Programming in Scala, 2nd Edition
– Martin Odersky, Lex Spoon & Bill Venners
Obrigado!