Comparativo entre Go e Lua

2,806 views

Published on

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
2,806
On SlideShare
0
From Embeds
0
Number of Embeds
12
Actions
Shares
0
Downloads
1
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide



  • Explicar o que é paradigma concorrente.

  • Explicar orientado a objetos (protótipo)

    From 1977 until 1992, Brazil had a policy of strong trade barriers (called a “market reserve”) for computer hardware and software motivated by a nationalistic feeling that Brazil could and should produce its own hardware and software. In that atmosphere, Tecgraf’s clients could not afford, either politically or financially, to buy customized software from abroad: by the market reserve rules, they would have to go through a complicated bureaucratic process to prove that their needs could not be met by Brazilian companies. Added to the natural geographical isolation of Brazil from other research and development centers, those reasons led Tecgraf to implement from scratch the basic tools it needed.
  • DEL não influenciou no projeto da linguagem Lua. A influência principal da DEL no nascimento da Lua foi a percepção de que grande parte de programas complexos pode ser escrito utilizando
    “embeddable scripting languages”.


  • * Citar que tipos de aplicações tem sido desenvolvidas com essa linguagens. *

    Rob Pike disse que Go tem sido utilizada internamente na Google.


    Scripts em Lua para o nmap são utilizados para (por ex.): explorar vulnerabilidades, verificar serviços de rede e detectar vulnerabilidades.

    Monotone é um sistema de controle de versões distribuído (como Git, Mercurial, Bazaar, ...). O que o Monotone faz é utilizar a linguagem Lua para permitir que hooks tenham seu comportamento modificado.

    FarCry e Crysis também utilizam Lua (só para dizer que tem outros jogos famosos que utilizam Lua).
  • * Citar que tipos de aplicações tem sido desenvolvidas com essa linguagens. *

    Rob Pike disse que Go tem sido utilizada internamente na Google.


    Scripts em Lua para o nmap são utilizados para (por ex.): explorar vulnerabilidades, verificar serviços de rede e detectar vulnerabilidades.

    Monotone é um sistema de controle de versões distribuído (como Git, Mercurial, Bazaar, ...). O que o Monotone faz é utilizar a linguagem Lua para permitir que hooks tenham seu comportamento modificado.

    FarCry e Crysis também utilizam Lua (só para dizer que tem outros jogos famosos que utilizam Lua).
  • * Citar que tipos de aplicações tem sido desenvolvidas com essa linguagens. *

    Rob Pike disse que Go tem sido utilizada internamente na Google.


    Scripts em Lua para o nmap são utilizados para (por ex.): explorar vulnerabilidades, verificar serviços de rede e detectar vulnerabilidades.

    Monotone é um sistema de controle de versões distribuído (como Git, Mercurial, Bazaar, ...). O que o Monotone faz é utilizar a linguagem Lua para permitir que hooks tenham seu comportamento modificado.

    FarCry e Crysis também utilizam Lua (só para dizer que tem outros jogos famosos que utilizam Lua).
  • * Citar que tipos de aplicações tem sido desenvolvidas com essa linguagens. *

    Rob Pike disse que Go tem sido utilizada internamente na Google.


    Scripts em Lua para o nmap são utilizados para (por ex.): explorar vulnerabilidades, verificar serviços de rede e detectar vulnerabilidades.

    Monotone é um sistema de controle de versões distribuído (como Git, Mercurial, Bazaar, ...). O que o Monotone faz é utilizar a linguagem Lua para permitir que hooks tenham seu comportamento modificado.

    FarCry e Crysis também utilizam Lua (só para dizer que tem outros jogos famosos que utilizam Lua).

  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Em Lua: tables, threads, functions e userdata são sempre referências (quando são retornadas de funções, passadas para funções em atribuições, etc). Strings não são duplicadas internamente, então se duas variáveis contém uma string igual então, na verdade, as duas internamente apontam para o mesmo objeto.
  • Importante observar que somente o tipo interface da Go passa por verificação em tempo de execução. Demais são tratados como numa linguagem de tipagem estática.
  • Importante observar que somente o tipo interface da Go passa por verificação em tempo de execução. Demais são tratados como numa linguagem de tipagem estática.
  • Importante observar que somente o tipo interface da Go passa por verificação em tempo de execução. Demais são tratados como numa linguagem de tipagem estática.
  • Importante observar que somente o tipo interface da Go passa por verificação em tempo de execução. Demais são tratados como numa linguagem de tipagem estática.
  • Observações:

    * Muitos tipos numéricos em Go é devido ao propósito da linguagem: Programação de sistemas costuma conter situações que exigem tamanhos específicos (devido a especificidades de dispositivos e/ou consumo de memória, por exemplo).

    * Números complexos não são diretamente suportados pela Lua.

    * nil também está presente na linguagem Go, porém, na forma de um identificador pré-declarado (como NULL em C).








  • * Verificar se um elemento, em Lua, está presente não é bem definido. Uma chave não presente retorna nil, porém é possível definir o valor de qualquer outra chave como nil:
    x = {oi = nil}; print(x[“oi”], x[“tchau”]) --> “nil nil”
    * Remover um elemento de uma table equivale a definir sua chave como nil: tabela[“elemento”] = nil
    * Go utiliza atribuição múltipla para verificar se um elemento está presente ou não: _, presente = x[“oi”]
    Variável presente é um bool que indica se a chave “oi” está no map x ou não.
    * Ao “inverter” a atribuição múltipla, é possível remover o elemento de um map: tabela[“elemento”] = 0, false







  • Comentar que em Go todos os tipos, com exceção de tipo interface, passam por verificação estática. Interface é a exceção, tendo seu uso verificado em tempo de execução.

    Em Lua toda a verificação é feito em tempo de execução.
  • Comentar que em Go todos os tipos, com exceção de tipo interface, passam por verificação estática. Interface é a exceção, tendo seu uso verificado em tempo de execução.

    Em Lua toda a verificação é feito em tempo de execução.























  • Operador de negação (! e not) também é um operador lógico, mas não faz diferença ele sofrer avaliação curto-circuito ou não.
  • Sintaxe EBNF.


  • Compilador do Go ainda não verifica a restrição imposta para goto.
  • Compilador do Go ainda não verifica a restrição imposta para goto.
  • Compilador do Go ainda não verifica a restrição imposta para goto.
  • * “if ... end” é um comando, não uma expressão.

    * bloco é uma sequência de comandos opcionalmente separados por ;
  • * Expressão condicional pode ser omitida, sendo tomada como true;
    * Obriga o uso de “{” e “}” no if, porém :) pela gramática, o corpo do else não precisa estar entre “{“ e “}”. Resolve a ambiguidade do dangling-else!




  • primaryExp são expressões mais simples: conversão de tipo, chamada de funções, subscritos, ....

  • for i = 0, 0 do print(“oi”) !!






















  • Gerador de bits pseudorandômico.
    Observar o uso de gorotina; quarta forma do laço “for” (laço infinito).
  • 1. Uma comunicação pode proceder quando a expressão envolvida retorna true.
    * Go diz que no caso de múltiplas comunicações disponíveis, uma é escolhida de forma justa e uniforme.

  • Note que Go realmente obriga separar em pacotes (não que seja ruim):
    SourceFile ::= “package” ident “;” { importDecl “;” } { topLevelDecl “;” }

    gorotinas está certo, é outro termo criado pela Go.
  • Identificadores que são exportados significa que: o arquivo que importa tal pacote tem acesso somente a tais identificadores

    * Cada pacote pode também conter uma função init que pode ser utilizada para definir algum estado inicial, por exemplo. Se a função init for definida no pacote main também, então ela executa antes do main.main.
  • A função require não precisa ser necessariamente utilizada para carregar módulos lua, há meios de se fazer a mesma tarefa sem ela.

  • boilerplate é traduzido como “repetido” nesse contexto.

  • Polimorfismo de subtipo -> em linguagens que suportam herança seria algo como: se uma função aceitar um parametro de tipo (classe) T, então ela pode receber qualquer valor que seja subtipo (subclasse) de T.

    Observações: um tipo pode “implementar” várias interfaces (todos implementam a interface vazia); tipos não precisam especificar que implementam certas interfaces; em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: Tipos built-in não deixam de ser palavras reservadas; código utf8; Rã e Pato são novos tipos que são aliases para int, porém (novamente) em Go é permitido que tipos implementem métodos arbitrários.
  • Observações: uso de funções anônimas (Go também disponibiliza); código ascii (Ran invés de Rã); Lua não tem bem o conceito de classes que instanciam objetos.

  • Observações: essa árvore funciona como uma BST; nenhum membro do tipo nó pode ser acessado; “...” é o modo disponibilizado pela Go para funções com um número indefinido de parâmetros; new(tipo) aloca memória e retorna um ponteiro para o tipo especificado.
  • Observações: (relembrando) somente identificadores que iniciam com letra maiúscula são exportados.
  • Observações: (relembrando) somente identificadores que iniciam com letra maiúscula são exportados.
  • Observações: (relembrando) somente identificadores que iniciam com letra maiúscula são exportados.
  • Observações: (relembrando) somente identificadores que iniciam com letra maiúscula são exportados.
  • Observações: Ao fazer “module(x)” uma tabela de nome x é criada no espaço global e é tomada como o novo ambiente de referenciamento, ou seja, funções globais existentes (como print e setametatable) não são mais visíveis. Para “concertar” isso, fazemos “module(x, package.seeall)” para que a tabela de nome x herde os nomes globais presentes. Porém, ao fazer isso, os nomes globais passam a ser todos acessíveis a partir desse módulo.

    Lua também utiliza “...” para indicar que função recebe número variável de parâmetros, porém, quase que por mágica, “...” é substituído por “arg” dentro do corpo da função.
  • Observações: (relembrando) identificadores precedidos de “local” não são exportados;
  • Observações: (relembrando) identificadores precedidos de “local” não são exportados;
  • Observações: (relembrando) identificadores precedidos de “local” não são exportados;
  • Observações: (relembrando) identificadores precedidos de “local” não são exportados;
  • Em Lua, a meta tabela que deve ser criada é utilizada para conter as funções relacionadas ao tipo.

  • Comparativo entre Go e Lua

    1. 1. 1 COMPARATIVO ENTRE LINGUAGENS vs. Alexandre Moreno, Cássio Korogui, Daniel Hey, Guilherme Polo Julho, 2010
    2. 2. 2 HISTÓRICO
    3. 3. 3 HISTÓRICO Linguagem Go • Começou a ser projetada em 2007 na Google. • Projetistas: Ken Thompson, Robert Griesemer, Rob Pike. • Objetivo: Combinar a facilidade de uma linguagem interpretada e dinamicamente tipada com a eficiência e segurança de uma linguagem compilada e estaticamente tipada. • Finalidade: Servir como uma nova linguagem para programação de sistemas.
    4. 4. 4 HISTÓRICO Linguagem Go • Paradigmas: concorrente, imperativo, orientado a objetos. • Influências: • C: similaridades com a sintaxe; • Pascal/Modula/Oberon: declarações e pacotes; • Linguagem formal CSP (Limbo/Alef): concorrência
    5. 5. 5 HISTÓRICO Linguagem Lua • Criada em 1993 na Tecgraf, PUC-RIO. • Projetistas: Roberto Ierusalimschy, Luiz Henrique de Figueiredo e Waldemar Celes. • Surgiu a partir da idéia de que duas linguagens previamente desenvolvidas na Tecgraf poderiam ser combinadas e aumentadas para formar uma linguagem de uso geral. • DEL (Data Entry Language) e SOL (Simple Object Language) eram essas linguagens.
    6. 6. 6 HISTÓRICO Linguagem Lua • Objetivo: Criar uma linguagem altamente portável, genérica, pequena e simples na forma de uma biblioteca. • Finalidade: • Permitir que programas já existentes pudessem a incorporar; • Servir como alternativa a linguagens existentes na época com propósito similar (LISP, Python, Scheme, Tcl). • Paradigmas: funcional, imperativo, orientado a objetos (protótipo).
    7. 7. 7 HISTÓRICO Linguagem Lua • Influências: • SOL: sintaxe para construção de registros e listas. Também herdou o conceito de ser implementado como uma biblioteca; • Modula: sintaxe para estruturas de controle while, if e repeat until; • CLU: atribuição múltipla e funções que retornam múltiplos valores; • C++: idéia de que uma variável local pode ser declarada onde ela é utilizada; • SNOBOL/Awk: arrays associativos, chamados de tabelas em Lua.
    8. 8. 8 HISTÓRICO Tempo de 2 anos 16 anos vida Principal Programação Extensão uso de sistemas Concorrente, Funcional, imperativo, imperativo, Paradigmas orientado a orientado a objetos objetos
    9. 9. 8 HISTÓRICO Tempo de 2 anos 16 anos vida Uso interno na Principal Programação Google Extensão uso de sistemas Concorrente, Funcional, imperativo, imperativo, Paradigmas orientado a orientado a objetos objetos
    10. 10. 8 HISTÓRICO •Scripts para nmap; •Customização de Interface no WoW; •Configuração, UI, e outros no SimCity 4; •Customização do comportamento do Monotone; •... Tempo de 2 anos 16 anos vida Uso interno na Principal Programação Google Extensão uso de sistemas Concorrente, Funcional, imperativo, imperativo, Paradigmas orientado a orientado a objetos objetos
    11. 11. 9 TIPOS DE DADOS
    12. 12. 10 TIPOS DE DADOS •A linguagem Lua conta com apenas 8 tipos: • nil, boolean, number, string, userdata, thread, function e table.
    13. 13. 10 TIPOS DE DADOS •A linguagem Lua conta com apenas 8 tipos: • nil, boolean, number, string, userdata, thread, function e table. array associativo representa fluxos de execução independentes, utilizado para implementar corotinas bloco de memória vindo de um aplicativo em C cadeia de caracteres de 8 bits números reais (internamente: ponto flutuante de precisão dupla) diferente de qualquer outro valor, utilizado para representar ausência de um valor útil
    14. 14. 11 TIPOS DE DADOS •A linguagem Lua conta com apenas 8 tipos: • nil, boolean, number, string, userdata, thread, function e table. • Por outro lado, Go disponibiliza 28 tipos: • bool, string, array, struct, pointer, function, interface, slice, map, channel;
    15. 15. 11 TIPOS DE DADOS •A linguagem Lua conta com apenas 8 tipos: • nil, boolean, number, string, userdata, thread, function e table. • Por outro lado, Go disponibiliza 28 tipos: • bool, string, array, struct, pointer, function, interface, slice, map, channel; array de caracteres unicode codificados em UTF-8 array associativo (representação interna em bytes) fornece um mecanismo de sincronização entre duas tipo dinâmico funções em execução concorrente
    16. 16. 12 TIPOS DE DADOS •A linguagem Lua conta com apenas 8 tipos: • nil, boolean, number, string, userdata, thread, function e table. • Por outro lado, Go disponibiliza 28 tipos: • bool, string, array, struct, pointer, function, interface, slice, map, channel; • Numéricos: uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128, byte (alias para uint8), uint, int, float, complex, uintptr.
    17. 17. 13 TIPOS DE DADOS Strings • As duas linguagens fornecem um tipo string imutável. • Em Lua, operações com strings são realizadas através da biblioteca “string” da linguagem. • Versões mais recentes da linguagem (5.1+) permitem um estilo orientado a objetos: minhastr:lower() ao invés de string.lower(minhastr). • Go também contém um pacote (biblioteca) para manipulação de strings. Porém optou-se por usar uma função “len”, fora desse pacote, para comprimento de string e outros objetos que podem ter seu tamanho obtido.
    18. 18. 14 TIPOS DE DADOS Funções • Ambas linguagens dispõem de um tipo para as funções declaradas, tratando-as como objetos de primeira classe (em Lua todos os valores são de primeira classe). • Isso significa que (SICP): • Funções podem ser passadas como argumentos; • Podem ser retornadas como resultado; • Podem ser nomeadas por uma variável qualquer; • Também podem ser inclusas em estruturas de dados.
    19. 19. 15 TIPOS DE DADOS Arrays • Go disponibiliza o tipo array para se construir arrays, enquanto que Lua utiliza o tipo table para simular arrays. • As duas linguagens aceitam valores inteiros como subscritos, sendo que em Go o índice inicia em 0 enquanto que na outra inicia-se 1. • Isso é válido em Lua somente enquanto não utilizamos nenhum “recurso” adicional das tabelas, isto é: x = {1, 2, 3}; print(x[1]) “1” x = {[0] = 1, 2, 3}; print(x[1]) “2”
    20. 20. 15 TIPOS DE DADOS Arrays • Go disponibiliza o tipo array para se construir arrays, enquanto que Lua utiliza o tipo table para simular arrays. • As duas linguagens aceitam valores inteiros como subscritos, sendo que em Go o índice inicia em 0 enquanto que na outra inicia-se 1. • Isso é válido em Lua somente enquanto não utilizamos nenhum “recurso” adicional das tabelas, isto é: x = {1, 2, 3}; print(x[1]) “1” x = {[0] = 1, 2, 3}; print(x[1]) “2”
    21. 21. 16 TIPOS DE DADOS Arrays • EmGo, arrays são especificadas com uma expressão constante que define seu tamanho. Ex.: var ponto [3]int • Em tempo de compilação é verificado se acessos com expressões constantes não ultrapassam o limite da array; • Em tempo de execução os outros casos de acesso são verificados. • Em Lua, arrays são dinâmicos no heap. Ao acessar uma posição que não pertence ao array é retornado nil.
    22. 22. 17 TIPOS DE DADOS Arrays • Arrays podem ser inicializadas no momento da declaração nas duas linguagens: • Go: z := [10]int {1, 2, 3} • Lua: z = {1, 2, 3} • Na Go, os outros elementos (de 3 a 9) são inicializados em 0. • A linguagem também permite especificar posições específicas para serem inicializadas: z := [10]int {0:1, 2:2, 4:3}
    23. 23. 18 TIPOS DE DADOS Arrays •A biblioteca “table” da Lua fornece operações como de concatenação (de elementos de uma tabela/array) e ordenação. • Go optou por realizar ordenação através de um pacote chamado “sort”. • Qualquer coleção pode ser ordenada se ela implementa a interface sort.Interface. em Go utilizam a sintaxe x[inicio:fim], onde x é um • Slices array qualquer e ambos os índices são incluídos. Lua não disponibiliza slices.
    24. 24. 19 TIPOS DE DADOS Arrays Multidimensionais • Nenhuma dessas linguagens tem naturalmente o conceito de arrays multidimensionais como se vê em Matlab (por exemplo). • Porém, as duas fornecem meios alternativos: • Go: var x [2][3]float • Lua: x = {{}, {}} • Operaçõesnesses arrays devem ser feitas individualmente em cada dimensão.
    25. 25. 20 TIPOS DE DADOS Arrays Associativos •O tipo table em Lua é utilizado para se criar arrays associativos, Go utiliza o tipo map para essa finalidade. • Porém, Lua permite que esse tipo contenha pares chave/ valor de todos os tipos (exceto nil como chave) enquanto Go limita o tipo do par chave/valor ao especificado na declaração. são utilizadas também para criar registros, arrays • tables comuns, e outros tipos de estruturas. Tabelas são o único mecanismo de estruturação de dados em Lua.
    26. 26. 21 TIPOS DE DADOS Arrays Associativos • As duas implementações permitem arrays associativos de tamanho dinâmico. • O acesso à elementos ocorre de forma similar à acesso de elementos de arrays – por subscrito. • A diferença é que os índices não precisam ser inteiros; • Na linguagem Go, é possível fazer uso da atribuição múltipla para obter informação adicional; • Lua permite uma notação adicional para acesso, equivalente ao acesso de campos de um registro em C.
    27. 27. 22 TIPOS DE DADOS Ponteiros • Lua não disponibiliza ponteiros, fato comum a linguagens de sua classe. • Go possui o tipo uintptr, que é capaz de armazenar um endereço qualquer. Diferentemente de C, não há aritmética de ponteiros: • Com isso, não é possível derivar endereços ilegais; • Simplifica a implementação do coletor de lixo da linguagem. • Também não há ponteiros pendurados (dangling pointers) em Go.
    28. 28. 23 TIPOS DE DADOS Ponteiros • Porém, o seguinte código compila: var bp *int = nil; print(*bp)
    29. 29. 23 TIPOS DE DADOS Ponteiros • Porém, o seguinte código compila: var bp *int = nil; print(*bp) dereferencia bp para imprimir representação da memória apontada atribui nil para o ponteiro bp
    30. 30. 24 TIPOS DE DADOS Ponteiros • Porém, o seguinte código compila: var bp *int = nil; print(*bp) • Em tempo de execução: • panic: runtimeerror: invalid memory address or nil pointer dereference • “NullReferences: The Billion Dollar Mistake” - Tony Hoare
    31. 31. 25 VERIFICAÇÃO DE TIPOS
    32. 32. 26 VERIFICAÇÃO DE TIPOS • Go é quase fortemente tipada. • Pacote “unsafe” incluso na linguagem permite violar o sistema de verificação de tipos. • Lua é fracamente tipada. • Linguagem tenta fazer a coerção de string para number em operações aritméticas: print("1" + 1, "1" + "1.e7") “2 10000001” print("1" + "a") attempt to perform arithmetic on a string value
    33. 33. 27 VERIFICAÇÃO DE TIPOS • Go é quase fortemente tipada. • Pacote “unsafe” incluso na linguagem permite violar o sistema de verificação de tipos. • Lua é fracamente tipada. • Linguagem tenta fazer a coerção de string para number em operações aritméticas. • Quantidade de argumentos passados para uma função não é levado em conta. Um argumento formal é nil se ele não receber um valor; e argumentos extras são simplesmente ignorados.
    34. 34. 28 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
    35. 35. 29 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Regras de Precedência * / % << >> & &^ ^ unário + - | ^ not # - != == < <= > >= * / % <- + - && .. || < > <= >= ˜= == and Menor or
    36. 36. 29 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Regras de Precedência * / % << >> & &^ ^ unário + - | ^ not # - != == < <= > >= * / % <- + - && .. || < > <= >= ˜= == and Menor or
    37. 37. 29 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Regras de Precedência exponenciação bit clear (bitwise and not) tamanho xor * / % << >> & &^ ^ unário ou bitwise not unário + - | ^ not # - especifica direção != == < <= > >= * / % de um tipo <- + - channel && .. concatenação || < > <= >= ˜= == != and Menor or
    38. 38. 30 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Regras de Associação • Nalinguagem Lua, os operadores de concatenação (“..”) e exponenciação (“^”) são associativos a direita. Demais operadores são associativos a esquerda. • Todos os operadores em Go são associativos a esquerda. • Asduas linguagens permitem o uso de parênteses para forçar outra ordem de precedência.
    39. 39. 31 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Sobrecarga de Operadores •A linguagem Go não oferece recursos para sobrecarga de operadores. • Atravésde meta métodos em meta tabelas, Lua permite sobrecarregar operadores.
    40. 40. 31 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Sobrecarga de Operadores •A linguagem Go não oferece recursos para sobrecarga de operadores. • Atravésde meta métodos em meta tabelas, Lua permite sobrecarregar operadores. pt1 = {x=3, y=2}; pt2 = {x=2, y=-1} function pt_add (a, b) return {x = a.x+b.x, y = a.y+b.y} end metatabela = {__add = pt_add} setmetatable(pt1, metatabela) pt3 = pt1 + pt2 print(pt3.x, pt3.y) “5 1”
    41. 41. 32 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Coerções • Go não fornece conversões implícitas entre tipos numéricos. • Tipos int e int32 são considerados como tipos distintos mesmo numa arquitetura de 32 bits;
    42. 42. 32 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Coerções • Go não fornece conversões implícitas entre tipos numéricos. • Tipos int e int32 são considerados como tipos distintos mesmo numa arquitetura de 32 bits; var x int = 6 var y int32 = 4 print(x + y) invalid operation: x + y (type int + int32)
    43. 43. 33 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Coerções • Go não fornece conversões implícitas entre tipos numéricos. • Tipos int e int32 são considerados como tipos distintos mesmo numa arquitetura de 32 bits; • Lua representa todos os números num programa com um único tipo: number. Logo não há coerções entre tipos numéricos. • Porém, um tipo string sofre coerção quando um operador aritmético é aplicado.
    44. 44. 34 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Expressões Relacionais • Lua e Go diferem apenas no operador “não igual”: • A primeira utiliza ~= e a outra != • As duas linguagens produzem um valor de tipo booleano. • Os operadores relacionais (<, >, <=, >=, ˜=, ==) em Lua não utilizam a coerção de string para number. • Na linguagem Go, os operadores == e != podem ser aplicados a quase todos os tipos (exceto array e struct). • Demais operadores (<, >, <=, >=) podem ser aplicados somente a inteiros, ponto flutuante e strings.
    45. 45. 35 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Avaliação Curto-Circuito • Todos os operadores lógicos em Go (&&, ||) e em Lua (and, or) são avaliados em curto-circuito. • Operadores lógicos em Lua não podem ser sobre carregados (não há meta métodos previstos para eles), garantindo a avaliação curto circuito.
    46. 46. 36 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Atribuição em Lua • Tem a seguinte sintaxe: Não-terminal • var {, var} = exp {, exp} Elemento EBNF Terminal • Aceita atribuições múltiplas; • Se houver mais expressões que variáveis, elas são descartadas; • Se houver mais variáveis que expressões, as excedentes recebem nil; • Operadores compostos não são aceitos. • Atribuição não é tratada com uma expressão.
    47. 47. 37 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO Atribuição em Go • Tem a seguinte sintaxe: + | - | | |^ • exp {, exp} [add_op | mul_op] = exp {, exp} *| / | % | << | >> | & | &^ • Aceita atribuições múltiplas; • Lado esquerdo e direito devem conter a mesma quantidade de valores após as expressões serem avaliadas; • Aceita operadores compostos. • Atribuição não é tratada com uma expressão. • Cada atribuição deve ser compatível. http://golang.org/doc/go_spec.html#Properties_of_types_and_values
    48. 48. 38 ESTRUTURAS DE CONTROLE
    49. 49. 39 ESTRUTURAS DE CONTROLE • Estruturas de controle em Lua não possuem múltiplas entradas. • Go disponibiliza a declaração goto, logo todas as estruturas de controle podem possuir múltiplas entradas. • Declarações rotuladas podem ser alvo tanto do goto quanto de break e continue. • Uma restrição: executar um goto não pode alterar o ambiente de referenciamento.
    50. 50. 39 ESTRUTURAS DE CONTROLE • Estruturas de controle em Lua não possuem múltiplas entradas. • Go disponibiliza a declaração goto, logo todas as estruturas de controle podem possuir múltiplas entradas. • Declarações rotuladas podem ser alvo tanto do goto quanto de break e continue. • Uma restrição: executar um goto não pode alterar o ambiente de referenciamento. goto exit resultado := 3 Erro! Ao pular para exit, resultado exit: passou a fazer parte do escopo
    51. 51. 40 ESTRUTURAS DE CONTROLE Seleção bidirecional • Sintaxe geral em Lua: • if exp then bloco {elseif exp then bloco} [else bloco] end • Aceita uma expressão qualquer (aritmética, lógica, construtor de tabela, ...); • Se expfor avaliada como false ou nil, a expressão é tida como falsa.
    52. 52. 41 ESTRUTURAS DE CONTROLE Seleção bidirecional • Sintaxe geral em Go: • if [simplestmt ;] [expressão] { {stmt ;} } [else stmt] expressão condicional aritmética/lógica Permite realizar atribuição, declarar novas variáveis, incrementar/decrementar variável ou uma expressão qualquer antes de avaliar a expressão de condição.
    53. 53. 42 ESTRUTURAS DE CONTROLE Seleção múltipla • Em Lua é possível realizar seleção múltipla somente através da combinação de seletores bidirecionais. • Go disponibiliza switch em duas formas: • switch de expressões; • switch de tipos.
    54. 54. 43 ESTRUTURAS DE CONTROLE Seleção múltipla em Go • Sintaxe geral de switch de expressões: • switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} } case expressão {, expressão} default
    55. 55. 44 ESTRUTURAS DE CONTROLE Seleção múltipla em Go • Sintaxe geral de switch de expressões: • switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} } • Expressões de uma cláusula não precisam ser constantes; são avaliadas da esquerda para direita e de cima para baixo.
    56. 56. 45 ESTRUTURAS DE CONTROLE Seleção múltipla em Go • Sintaxe geral de switch de expressões: • switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} } • Somente a última instrução de uma cláusula default ou case pode ser a declaração fallthrough, indicando que o controle deve ser passado para o início da próxima cláusula. • Caso fallthrough não seja utilizado, controle é desviado para o final do switch.
    57. 57. 46 ESTRUTURAS DE CONTROLE Seleção múltipla em Go • Sintaxe geral de switch de tipos: • switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}} case type {, type} default [ident :=] primaryExp . ( type )
    58. 58. 47 ESTRUTURAS DE CONTROLE Seleção múltipla em Go • Sintaxe geral de switch de tipos: • switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}} • Esse tipo de switch compara tipos ao invés de valores. • Declaração fallthrough não é permitida aqui.
    59. 59. 48 ESTRUTURAS DE CONTROLE Laços controlados por contador • Lua disponibiliza duas formas para o comando for, uma delas é a versão numérica: • for ident = exp1, exp2 [, exp3] do bloco end • Iteração inicia com valor de exp1, prosseguindo até exp2 com passos de tamanho exp3; • Se exp3 for omitida, o passo é 1; • As três (ou duas) expressões são avaliadas antes do laço iniciar e todas devem produzir números; • A variável criada com nome ident é local ao laço.
    60. 60. 49 ESTRUTURAS DE CONTROLE Laços controlados por contador • Go disponibiliza quatro formas para o comando for, uma delas pode ser utilizada como numérica: • for [simplestmt1] ; [expressão] ; [simplestmt2] { {stmt ;} } • simplestmt1 pode conter declaração de variável, simplestmt2 não; • variável(is) declarada(s) em simplestmt1 tem escopo local ao for e podem ser alteradas dentro do bloco; • A expressão é avaliada no início de cada iteração, simplestmt1 somente no início do laço e simplestmt2 após cada execução do bloco; • Se expressão for omitida, é um loop infinito;
    61. 61. 50 ESTRUTURAS DE CONTROLE Laços controlados logicamente • Lua disponibiliza duas formas, separando instruções de pré-teste e pós- teste: • repeat bloco until exp • while exp do bloco end • Duas formas do for da Go servem para controle de repetição baseada em expressão booleana: • Na forma do slide anterior, basta omitir a primeira e última parte opcional; • A outra forma utiliza pré-teste também: for expressao { {stmt ;} }
    62. 62. 51 ESTRUTURAS DE CONTROLE Controle de laço localizado pelo usuário • As duas linguagens disponibilizam break e continue com a semântica usual. • Go permite rotular declarações e permite que break e continue transfiram o controle para um rótulo específico. • No caso do break rotulado, o rótulo deve preceder um for para indicar que o mesmo será encerrado; • No caso do continue rotulado, o rótulo deve preceder um for para indicar que o mesmo terá sua execução “pulada”.
    63. 63. 52 ESTRUTURAS DE CONTROLE Laços baseados em estrutura de dados •Asegunda forma do for disponibilizada pela Lua tem a seguinte sintaxe: • for ident {, ident} in exp {, exp} do bloco end • As expressões são avaliadas uma única vez; • Osidentificadores criados para guardar os resultados das expressões são locais ao laço;
    64. 64. 52 ESTRUTURAS DE CONTROLE Laços baseados em estrutura de dados •Asegunda forma do for disponibilizada pela Lua tem a seguinte sintaxe: • for ident {, ident} in exp {, exp} do bloco end • As expressões são avaliadas uma única vez; • Osidentificadores criados para guardar os resultados das expressões são locais ao laço; equivalentes for k,v in pairs({42, a = "A"}) do for k,v in next,{42, a = "A"} do print(k,v) print(k,v) end end
    65. 65. 53 ESTRUTURAS DE CONTROLE Laços baseados em estrutura de dados •A terceira forma do for da linguagem Go é utilizada para iterar sobre todas os elementos de um array, string, slice, map ou valores recebidos em um channel. • for expressão {, expressão} (=|:=) range expressão • Ao utilizar a forma com := as variáveis criadas deixam de existir no final do laço;
    66. 66. 53 ESTRUTURAS DE CONTROLE Laços baseados em estrutura de dados •A terceira forma do for da linguagem Go é utilizada para iterar sobre todas os elementos de um array, string, slice, map ou valores recebidos em um channel. um desses tipos • for expressão {, expressão} (=|:=) range expressão • Ao utilizar a forma com := as variáveis criadas deixam de existir no final do laço;
    67. 67. 53 ESTRUTURAS DE CONTROLE Laços baseados em estrutura de dados •A terceira forma do for da linguagem Go é utilizada para iterar sobre todas os elementos de um array, string, slice, map ou valores recebidos em um channel. um desses tipos • for expressão {, expressão} (=|:=) range expressão • Ao utilizar a forma com := as variáveis criadas deixam de existir no final do laço; x := [3]int{1, 2, 3} sum := 0 for _, v := range x { ignora índices retornados sum += v }
    68. 68. 54 ESTRUTURAS DE CONTROLE Comandos Protegidos • Não disponível em Lua. • Go disponibiliza a instrução select: • Entreum conjunto de comunicações possíveis, escolhe uma para prosseguir; • Sintaxe parecida com switch.
    69. 69. 54 ESTRUTURAS DE CONTROLE Comandos Protegidos • Não disponível em Lua. • Go disponibiliza a instrução select: • Entreum conjunto de comunicações possíveis, escolhe uma para prosseguir; • Sintaxe parecida com switch. select { { commCase : { stmt ; } } } case (recvExpr | sendExpr) default [ expr (=|:=) ] <- expr expr <- expr
    70. 70. 55 ESTRUTURAS DE CONTROLE Comandos Protegidos em Go • Exemplo: package main func main() { canal := make(chan int); go func() { for { print(<-canal) } }(); for { select { case canal <- 0: case canal <- 1: } } }
    71. 71. 55 ESTRUTURAS DE CONTROLE Comandos Protegidos em Go • Exemplo: package main 00100001000010001110101011011101001100 10011000010110000100011111000111011101 func main() { 10000010001001001010010111111011011010 canal := make(chan int); 11001000111011101000111101110110101110 11011100101110100111101011110010110111 go func() { 00110001011010110100011010100100000010 for { print(<-canal) } 11011001100000010100010001101000101011 }(); 01101010110110011001110100001110000000 11100000000101010101011000011111001001 10001010000100011101100011101001110000 for { 10101001001111000100111001001100101111 01110010000000111111011010011001101110 select { 11110010110111000111100100011000011010 case canal <- 0: 11111000010100110010110110101101010010 case canal <- 1: 00001000110110001100111000100000010010 00101101000101100100000011110000000001 } 01000110011011011111111100001100000110 } 10001101000000101111011011100100101100 ... }
    72. 72. 56 ESTRUTURAS DE CONTROLE Comandos Protegidos em Go • Todas as expressões recvExpr e sendExpr são avaliadas, assim como o lado direito das sendExprs, de cima para baixo. 1. Se qualquer uma das comunicações puderem proceder, uma é escolhida e a respectiva comunicação juntamente com seu bloco de instruções são avaliados; 2. Se nenhuma comunicação puder proceder ... 2.1. e se houver uma cláusula default, então ela é executada; 2.2. e não houver uma cláusula default, o select bloqueia até o momento que alguma comunicação puder proceder.
    73. 73. 57 MODULARIZAÇÃO
    74. 74. 58 MODULARIZAÇÃO • Asduas linguagens permitem modularização através da sub-programação. • gorotinas e funções em Go; • corotinas e funções em Lua. • Além disso Go separa os programas em pacotes, obrigatoriamente. • Lua permite a criação de módulos.
    75. 75. 59 MODULARIZAÇÃO Pacotes Go • Início de um programa é definido como a função chamada “main” contida no pacote “main”*. • Todoarquivo pertence a um pacote, e um pacote pode ser formado por vários arquivos. • Um arquivo pode importar outros pacotes. • Apenas identificadores que declaram constantes, tipos, variáveis ou funções e que iniciam com letra maiúscula são exportados.
    76. 76. 60 MODULARIZAÇÃO Módulos Lua • Paracarregar módulos a função require ou loadlib podem ser utilizadas. •Aprimeira é frequentemente utilizada para carregar módulos escritos puramente em Lua; •A segunda é necessária para carregar módulos escritos em C na forma de biblioteca (.DLL, .so, .dylib, ...).
    77. 77. 61 MODULARIZAÇÃO Módulos Lua • Módulos podem ser criados de várias formas. • Exemplo: abacate.lua melancia.lua modulo = {} module("melancia", package.seeall) function modulo.oi() function oi() print("oi") print("oi oi") end end return modulo require "melancia" abacate = require "abacate" main.lua abacate.oi() melancia.oi()
    78. 78. 62 MODULARIZAÇÃO Módulos Lua • Módulos podem ser criados de várias formas. • Exemplo: •A partir da versão 5.1 existe a função module para facilitar a criação de módulos. • Elimina código boilerplate; • Símbolos que não devem ser exportados precisam ser precedidos de local. Ex.: local x = 3
    79. 79. 63 POLIMORFISMO
    80. 80. 64 POLIMORFISMO • Em Go, interfaces são utilizadas para obter polimorfismo universal de subtipo. • Interfaces definem um conjunto de métodos. • Um tipo automaticamente “implementa” uma interface se possuir um super-conjunto dos métodos definidos na interface. • Um parâmetro de tipo interface aceita qualquer tipo que a implementa.
    81. 81. 65 POLIMORFISMO • Em Go, interfaces são utilizadas para obter polimorfismo universal de subtipo. package main type StrInterface interface { str() string } type Rã int type Pato int func (t *Rã) str() string { return "croac" } func (t *Pato) str() string { return "quack" } func imprime(item StrInterface) { println(item.str()) } func main() { var r *Rã var p *Pato imprime(r); imprime(p) }
    82. 82. 65 POLIMORFISMO • Em Go, interfaces são utilizadas para obter polimorfismo universal de subtipo. package main Palavra reservada type StrInterface interface { str() string } Tipo built-in type Rã int Nome de função type Pato int String func (t *Rã) str() string { return "croac" } Outros func (t *Pato) str() string { return "quack" } func imprime(item StrInterface) { println(item.str()) } func main() { var r *Rã var p *Pato imprime(r); imprime(p) croac } quack
    83. 83. 66 POLIMORFISMO • EmLua, há polimorfismo universal paramétrico implícito – comum nas linguagens dinamicamente tipadas. function imprime(item) print(item:str()) end Ran = {} ran_mt = {__index = Ran} function Ran:new() return setmetatable({}, ran_mt) end function Ran:str() return "croak" end r = Ran:new() imprime(r) imprime({str = function () return "quack" end})
    84. 84. 67 TIPOS ABSTRATOS DE DADOS
    85. 85. 68 TIPOS ABSTRATOS DE DADOS Exemplo em Go package main import "./bintree" package bintree func main() { arvore := bintree.NovaÁrvore(42) type nó struct { arvore.Insere(11, 43, 13, 7) valor int arvore.EmOrdem() esq, dir *nó } } func NovaÁrvore(valor int) *nó { t := new(nó); t.valor = valor; return t } func (self *nó) EmOrdem() { em_ordem(self) } func (self *nó) Insere(valores ... int) { for i := 0; i < len(valores); i++ { insere(self, valores[i]) } }
    86. 86. 69 TIPOS ABSTRATOS DE DADOS Exemplo em Go package bintree type nó struct { valor int esq, dir *nó } func NovaÁrvore(valor int) *nó { t := new(nó); t.valor = valor; return t } func (self *nó) EmOrdem() { em_ordem(self) } func (self *nó) Insere(valores ... int) { for i := 0; i < len(valores); i++ { insere(self, valores[i]) } }
    87. 87. 69 TIPOS ABSTRATOS DE DADOS Exemplo em Go func em_ordem(x *nó) { if x.esq != nil { em_ordem(x.esq) } println(x.valor) if x.dir != nil { em_ordem(x.dir) } } package bintree func insere(x *nó, v int) *nó { if x == nil { x = NovaÁrvore(v) type nó struct { } else if v < x.valor { x.esq = insere(x.esq, v) valor int } else x.dir = insere(x.dir, v) esq, dir *nó return x } } func NovaÁrvore(valor int) *nó { t := new(nó); t.valor = valor; return t } func (self *nó) EmOrdem() { em_ordem(self) } func (self *nó) Insere(valores ... int) { for i := 0; i < len(valores); i++ { insere(self, valores[i]) } }
    88. 88. 70 TIPOS ABSTRATOS DE DADOS Exemplo em Lua require "bintree" x = bintree.arvore:nova(42) x:insere(11, 43, 13, 7) x:em_ordem() module("bintree", package.seeall) arvore = {} local mt = {__index = arvore} function arvore:nova(valor) return setmetatable({valor = valor, esq = nil, dir = nil}, mt) end function arvore:em_ordem() em_ordem(self) end function arvore:insere(...) for i = 1, #arg do insere(self, arg[i]) end end
    89. 89. 71 TIPOS ABSTRATOS DE DADOS Exemplo em Lua module("bintree", package.seeall) arvore = {} local mt = {__index = arvore} function arvore:nova(valor) return setmetatable({valor = valor, esq = nil, dir = nil}, mt) end function arvore:em_ordem() em_ordem(self) end function arvore:insere(...) for i = 1, #arg do insere(self, arg[i]) end end
    90. 90. 71 TIPOS ABSTRATOS DE DADOS Exemplo em Lua local function em_ordem(x) if x.esq ~= nil then em_ordem(x.esq) end print(x.valor) if x.dir ~= nil then em_ordem(x.dir) end end local function insere(x, v) if x == nil then x = arvore:nova(v) module("bintree", package.seeall) elseif v < x.valor then x.esq = insere(x.esq, v) else x.dir = insere(x.dir, v) end arvore = {} return x local mt = {__index = arvore} end function arvore:nova(valor) return setmetatable({valor = valor, esq = nil, dir = nil}, mt) end function arvore:em_ordem() em_ordem(self) end function arvore:insere(...) for i = 1, #arg do insere(self, arg[i]) end end
    91. 91. 72 TIPOS ABSTRATOS DE DADOS 1. Criar uma meta 1. Criar um tipo; Como definir tabela para o tipo; 2. Definir métodos um TAD 2. Definir funções para o tipo. com prefixo “tipo”. Encapsulamento Pacotes Módulos Somente Não permite ocultar identificadores Visibilidade acesso a atributos exportados são do tipo visíveis
    92. 92. 73 REFERÊNCIAS • Blow, J. (2004). Game development: Harder than you think. ACM Queue, pages 31–32. • Cardelli, L. and Wegner, P. (1985). On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17:471–522. • Dijkstra, E. W. (1975). Guarded commands, non-determinacy and a calculus for the derivation of programs. In Proceedings of the international conference on Reliable software, New York, NY, USA. ACM. • Gabbrielli, M. and Martini, S. (2010). Programming Languages: Principles and Paradigms, chapter 9, pages 265– 275. Springer. • Go (2010a). The go programming language specification. http://golang.org/doc/go_spec.html. Acessado em 16 de Junho de 2010. • Go (2010b). Language design faq. http://golang.org/doc/go_lang_faq.html. Acessado em 16 de Junho de 2010. • Hoare, T. (2009). Null references: The billion dollar mistake. Apresentado na QCon London. • Ierusalimschy, R., de Figueiredo, L. H., and Celes, W. (2006). Lua 5.1 Reference Manual. Lua.org. • Ierusalimschy, R., de Figueiredo, L. H., and Celes, W. (2007). The evolution of lua. In: HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages. ACM Press. • Sebesta, R. W. (2001). Concepts of Programming Languages. Addison Wesley, 5th edition. • Taivalsaari, A. (1996). Classes vs. prototypes - some philosophical and historical observations. In Journal of Object-Oriented Programming, pages 44–50. SpringerVerlag.

    ×