Linguagem Go
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
1,481
On Slideshare
1,481
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
40
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Paradigmas de Linguagens de Programação Delano Oliveira Janderson Jason Luan Barbosa Natã Melo {delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br
  • 2. Agenda Introdução Valores e Tipos Armazenamento Associações Abstrações Unidades de Programa Sistemas de Tipos Sequenciadores Concorrência Conclusão PLP - Linguagem Go 2
  • 3. Introdução
  • 4. Introdução Motivação Sintaxe e Semântica Processador da Linguagem Outras Características PLP - Linguagem Go 4
  • 5. Motivação Compilada Sensação de uma linguagem dinâmica Simula Orientação a Objetos Possui Garbage Collection Multi-processamento Open-source 18a linguagem mais usada no mundo segundo o site da Tiobe PLP - Linguagem Go 5
  • 6. Sintaxe e Semântica Go reúne características sintáticas de várias linguagens Possui uma Sintaxe simples e intuitiva A sintaxe é descrita por uma Gramática (Extended Backus-Naur Form) Semântica Operacional PLP - Linguagem Go 6
  • 7. Processador da Linguagem Compilador: gccgo (6g, 6l, 8g, 8l) Código Fonte *.8 ou *.6 Executável PLP - Linguagem Go 7
  • 8. Outras Características Criada pela Google e lançada em novembro de 2009 Equipe: Robert Griesemer, Rob Pike e Ken Thompson PLP - Linguagem Go 8
  • 9. Valores & Tipos
  • 10. Valores & Tipos Valores  Tipos  Boolean  Primitivos  Numérico  Compostos  String  Recursivo  Array  Struct  Checagem de Tipos  Equivalência de Tipos  Ponteiros  Princípio da Completude  Abstração de função e  Expressões procedimento  Mapa  Channel PLP - Linguagem Go 10
  • 11. Valores else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 11
  • 12. Valores Númericos Arrays Abstração de Função else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Abstração de Procedimento Ponteiro Booleanos Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 12
  • 13. Tipos Primitivos var barra string = "===== “ var contagemEmpate int = 0 var travou bool = false var porcentagem float = 10.5 Boolean – Representa o conjunto de valores booleanos Numeric – Representa o conjunto de valores inteiros ou valores de ponto- flutuante  uint(8, 16, 32, 64), int(8, 16, 32, 64), float(32, 64), complex(64, 128) String – Array de bytes. Imutável PLP - Linguagem Go 13
  • 14. Tipos Compostos Produtos Cartesianos : Structs type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 14
  • 15. Tipos Compostos Produtos Cartesianos : Structs [][]*Peca x int type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 15
  • 16. Tipos Compostos Tipos Recursivos: Structs type Node struct { valor Tupla next *Node }  Implementados através de ponteiros. Go não dá suporte:  União Disjunta  Conjuntos Potência PLP - Linguagem Go 16
  • 17. Checagem de Tipos Go é estaticamente e fortemente tipada. func main (){ var nome string = "plp" nome = 18 } prog.go:6: cannot convert 18 to type string prog.go:6: cannot use 18 (type int) as type string in assignment func main (){ Erro ao tentar Fortemente dez_decimal := 10.0 var dez int = dez_decimal compilar!!! } prog.go:6: cannot use dez_decimal (type float) as type int in assignment PLP - Linguagem Go 17
  • 18. Equivalência de Tipos Go dá suporte a equivalência nominal package main type Peca struct {cor int, dama bool} type Tupla struct {tamanho int,comida bool} func (peca *Peca) EhDama () (bool){ return peca.dama } func main (){ var tupla *Tupla = new(Tupla) Erro ao tentar tupla.EhDama() compilar!!! } prog.go:15: tupla.EhDama undefined (type Tupla has no field EhDama) Go não dá suporte a equivalência estrutural! PLP - Linguagem Go 18
  • 19. Princípio da Completude Go quebra o princípio da completude de tipo.  É necessário o uso do tipo File para manipular arquivos persistentes.  Funções só podem retornar valores primitivos ou ponteiros. func (tabuleiro *Tabuleiro) IsZerou (cor int) bool if (…){ return false } return true } PLP - Linguagem Go 19
  • 20. Expressões Literais: Valores dos tipos bool, int, uint, float, string Agregados: array, maps, structs Funções Go não dá suporte a:  Expressões Condicionais  Expressões Iterativas PLP - Linguagem Go 20
  • 21. Armazenamento
  • 22. Armazenamento Variáveis e Atualização  Tipos de Comandos Arrays  Skip Semântica de Cópia x  Atribuição Semântica de Referência  Chamada de Variáveis procedimento  Locais e Globais  Comandos  Heap  Sequencial  Persistentes  Colateral  Condicional  Expressões com Efeitos Colaterais PLP - Linguagem Go 22
  • 23. Variáveis e Atualização Os valores armazenáveis (storables) são os valores dos tipos primitivos e ponteiros Variáveis Temporárias  Todas as variáveis, com exceção do tipo File Variáveis Persistentes  Em Go, as variáveis persistentes são do tipo File PLP - Linguagem Go 23
  • 24. Variáveis e Atualização Go dá suporte a atualização seletiva e atualização total var posicaoFinal Coordenada; Seletiva posicaoFinal.x = 1; posicaoFinal.y = 2; var posicaoInicial Coordenada; Total posicaoInicial = posicaoFinal; PLP - Linguagem Go 24
  • 25. Arrays Go dá suporte a Arrays Estáticos. Os arrays possuem tamanho fixo e não podem armazenar valores de tipos diferentes. func (tabuleiro *Tabuleiro) GetPecas (cor int) ([12]*Tupla){ var pecas [12] *Tupla; (...) return pecas; } PLP - Linguagem Go 25
  • 26. Semântica de Cópia x Semântica de Referência Semântica de cópia – utilizada para valores de qualquer tipo. Semântica de Referência – utilizada apenas para ponteiros. var posicao1 Coordenada; posicao1.x = 1; posicao1.y = 2; var posicao2 *Coordenada; var posicao3 *Coordenada; Por Referência posicao2 = &posicao1; posicao3 = posicao2; posicao3.x = 5; posicao3.y = 5; Por Cópia PLP - Linguagem Go 26
  • 27. Variáveis Locais e Globais Variáveis Globais são declaradas da seguinte forma: var + nomeVariavel + tipo Para variáveis locais podem ser utilizados açúcares sintático var jogadorDaVez string = “tabuleiro” Variável Global func main() { tamanho := 10; Açúcar if (...){ Variáveis LocaisSintático var numBombas = 15; } } PLP - Linguagem Go 27
  • 28. Variáveis Heap Variáveis podem ser declaradas a partir da palavra reservada new. Não existe um mecanismo para o programador destruir as variáveis. Go possui Garbage Collection. Alocação de memória var tabuleiro_jogo *Tabuleiro = new (Tabuleiro) PLP - Linguagem Go 28
  • 29. Variáveis persistentes São do tipo “File” oldfile := "text.txt" newfile := "text2.txt" doc, _ := ioutil.ReadFile(oldfile) ioutil.WriteFile(newfile,doc,0644) PLP - Linguagem Go 29
  • 30. Skip e Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Não há atribuição múltipla em Go. PLP - Linguagem Go 30
  • 31. Skip e Atribuição Skip usado para separar expressões Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Açúcar sintático Atribuição simultânea Não há atribuição múltipla em Go. PLP - Linguagem Go 31
  • 32. Chamada de Procedimentos Chamada de procedimento peca := new (Peca) peca.SetCor(Preto) //... func (peca *Peca) SetCor (cor int) { peca.cor = cor } Procedimento PLP - Linguagem Go 32
  • 33. Comando Sequencial meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; meuTabuleiro.n = 0 Separados por ponto-e-vírgula, meuTabuleiro.m = 0 ou por quebra de linha. meuTabuleiro.ganhou = falseComando Colateral Não existem comandos colaterais. PLP - Linguagem Go 33
  • 34. Comando Condicional Go dá suporte através de: if ,else e switch. var jogada int; if (ehHumano) { var pos [2]int = JogarHumano(); jogada = tabuleiro.Jogada(pos); } else { var pos [2]int = JogarAutomatico(); jogada = tabuleiro.Jogada(pos); } var aux string; switch opcao{ case 1: aux = "Jogar“ case 2: aux = "Ajuda" case 3: aux = "Fechar" } PLP - Linguagem Go 34
  • 35. Comandos Iterativos Iteração definida for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS; i++ { nodeAtual = new(Node); nodeAtual.SetValor(tuplaAtual); //... } Iteração indefinida Palavra reservada for for i > 0 { funcionando como o var a int = Random(n); comando while em var b int = Random(n); outras linguagens. //... } PLP - Linguagem Go 35
  • 36. Associações
  • 37. Associações Entidades Associáveis  Comando Bloco Escopo  Expressão Bloco Estrutura de Blocos  Princípio da Qualificação Visibilidade Declarações  Definição  Declaração de Tipo  Declaração de Variável  Declarações Colaterais  Declarações Sequenciais  Declarações Recursivas PLP - Linguagem Go 37
  • 38. Entidades Associáveis Valores primitivos e compostos Abstrações de funções e procedimentos Variáveis e Tipos meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; var Numero int = calculaNumDeMinas(n); const( MAX_MOVIMENTOS int = 50); PLP - Linguagem Go 38
  • 39. Escopo const s = 2; func incremento ( d int ) int { return d∗s; } func executaIncremento ( valor int ) int { const s = 3; return incremento ( valor ); } Saída: 10 func main () { fmt.Println( executaIncremento(5) ); } Em Go, o corpo de um bloco é avaliado no ambiente em que foi definido (associação estática). PLP - Linguagem Go 39
  • 40. Blocos: Estrutura e Visibilidade var tamanhoTabuleiro int = 10; for { var tamanhoTabuleiro = 15; for { var tamanhoTabuleiro = 20; imprime 20 fmt.Println( tamanhoTabuleiro ); break; } imprime 15 fmt.Println( tamanhoTabuleiro ) ; break; } imprime 10 fmt.Println( tamanhoTabuleiro ); Estrutura: blocos aninhados. Visibilidade: variáveis declaradas em blocos de escopo internos não são visíveis a blocos de escopo externos. PLP - Linguagem Go 40
  • 41. Definição As definições em Go podem ser de tipo, abstração de funções, abstração de procedimentos, variáveis, constantes. const( MAX_MOVIMENTOS int = 50) func Jogada() (int,int) { //… } Constante var posJogada; var posX *int; Abstração de função var posAux *int; Variáveis PLP - Linguagem Go 41
  • 42. Declaração de Tipo type Peca struct {  Go dá suporte a declaração de tipos cor int; dama bool; através da palavra reservada type. } O tipo Peca sendo declarado.Declaração de Variável var vertical string = "Coordenada Vertical: “; var valor int = 1; var decimal float = 1.0; PLP - Linguagem Go 42
  • 43. Declaração sequencial  Como a maioria das linguagens imperativas, Go dá suporte à declaração sequencial. tamanhoMaiorCaminho := 0; tamanhoCaminhoTupla := 0; var pilha *Node = nil; var caminhoAtual [MAXIMO_CAMINHOS] *Node;Declarações Colaterais Go não dá suporte a este tipo de declaração. PLP - Linguagem Go 43
  • 44. Declaração recursiva  Go dá suporte a declaração recursiva.func TomadaMaximaPeca(tabuleiro *Tabuleiro, posX int, posY int, cor int)([MAXIMO_CAMINHOS] *Node, int) { caminhos := tabuleiro.GetOpcoesComida(posX, posY, cor); for ;pilha != nil; { caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp,tuplaAtual.FicarX, tuplaAtual.FicarY, cor); return caminhosMaximos, tamanhoMaiorCaminho;} Chamada recursiva PLP - Linguagem Go 44
  • 45. Comando bloco Go dá suporte a comando bloco. func ( pilha ∗Node ) PrintValorProximo( ) { Println ( "|" , pilha.GetValor( ) , "|" ); next := pilha.GetNext( ); Println(next.GetValor()); } Declaração que é usada apenas pra executar o comando PLP - Linguagem Go 45
  • 46. Expressão bloco Go dá suporte a expressão bloco. func (peca *Peca) GetValue(peca2 *Peca)(bool){ valor1 := peca.EhDama() valor2 := peca2.EhDama() return valor1 && valor2 } Declarações usadas apenas para avaliar a expressão. PLP - Linguagem Go 46
  • 47. Princípio da Qualificação Go não viola o princípio da qualificação, pois é possível realizar qualquer computação dentro de um bloco. func (pilha *Node) GetNext() (*Node, *Tupla){ next := pilha.GetNext() valor := next.GetValor() func nome(){ //Corpo da funcao } return next, valor } Um bloco dentro do outro. PLP - Linguagem Go 47
  • 48. Abstrações
  • 49. Abstrações Tipos de Abstrações  Argumentos  Abstração de Função  Passagem de Parâmetros  Abstração de  Princípio da Procedimento Correspondência  Ordem de Avaliação Princípio da Abstração Parâmetros PLP - Linguagem Go 49
  • 50. Abstração de Função Go dá suporte a abstrações de funções através da palavra reservada func. A presença do retorno caracteriza a abstração de função. func calculaNumDeMinas(tamanho int) int{ numeroDeBombas := int(tamanho*tamanho*20/100); if (numeroDeBombas%2 == 0) { numeroDeBombas += 1; } //m sempre impar if (tamanho <= 10) { numeroDeBombas += 2; } return numeroDeBombas; } PLP - Linguagem Go 50
  • 51. Abstração de Procedimento Go usa a mesma palavra reservada para caracterizar uma Abstração de Procedimento, como em Abstrações de Funções. (func) A diferença que caracteriza a Abstração de Procedimento é a falta do retorno. func inicializarJogo() { tabuleiro.ReiniciaTabuleiro(); ehHumano = true; } PLP - Linguagem Go 51
  • 52. Princípio da abstração  Go não viola o princípio da abstração, pois é possível construir abstração sobre qualquer categoria sintática da linguagem, como por exemplo: variáveis, funções e procedimentos. PLP - Linguagem Go 52
  • 53. Parâmetros Como Go é fortemente tipada, os parâmetros devem possuir tipos definidos. Podem ser de qualquer tipo. type Peca struct { cor int dama bool } func (peca *Peca) EhDama () (bool){ return peca.dama } PLP - Linguagem Go 53
  • 54. Passagem de Parâmetros Em Go a passagem de parâmetros é por cópiavalor. func Inverter (i int) int { if(i != 0) { return 0 } return 1 } Go não dá suporte a passagem de parâmetros por referência, mas simula com o uso de ponteiros. func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() } Ponteiro PLP - Linguagem Go 54
  • 55. Princípio da Correspondência Go viola o princípio da correspondência, pois não existe um mecanismo de passagem de parâmetro correspondente a definição de constante. Código abaixo não é compilável.const constante = 10;func funcao ( c const ) const { return c ;}func main ( ) { fmt.Println ("Imprimir constante:" , funcao ( constante ) ) ;} Dá erro de sintaxe PLP - Linguagem Go 55
  • 56. Ordem de Avaliação  Eager Evaluation var p int; func main () { p = 3; print ( p ) } Saída: func print ( n int ) { Println(n); 3 p = 100; 3 Println(n); } PLP - Linguagem Go 56
  • 57. Unidades de Programa
  • 58. Unidades de Programa Pacotes Tipos Abstratos de Dados Objetos e Classes Unidades Genéricas PLP - Linguagem Go 58
  • 59. Pacotes As funções e variáveis globais que começam com letra Maiúscula serão visíveis para quem importar esse pacote. Caso contrário, a função fica com visibilidade privada.package tabuleiro//...func (meuTabuleiro *Tabuleiro) Ganhou() bool { return meuTabuleiro.ganhou;} Funções visíveisfunc (meuTabuleiro *Tabuleiro) AlguemGanhou(){ meuTabuleiro.ganhou = true;}func calculaNumDeMinas(tamanho int) int{ //... Função com return numeroDeBombas; visibilidade privada}/ PLP - Linguagem Go 59
  • 60. Tipo Abstrato de Dados package tabuleiro import (. "fmt"; . "./pecaPkg"; . "./util") type Tabuleiro struct {matriz [8] [8] *Peca} func (tabuleiro *Tabuleiro) SetPecaDama (x int, y int){ tabuleiro.matriz[x][y].SetDama(true) } //... PLP - Linguagem Go 60
  • 61. Objetos e Classes  Go não tem Objetos e Classes, porém, simula-os através de structs e funções ligadas a esses tipos. type Node struct { valor Tupla next *Node } //... func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() }Unidades Genéricas  Go não dá suporte a unidades genéricas. PLP - Linguagem Go 61
  • 62. Sistemas de Tipos
  • 63. Sistema de Tipos Monomorfismo Sobrecarga Polimorfismo Paramétrico Polimorfismo por Inclusão Interfaces Coerção PLP - Linguagem Go 63
  • 64. Monomorfismofunc (meuTabuleiro *Tabuleiro) Ganhou() bool{ return meuTabuleiro.ganhou;}func (meuTabuleiro *Tabuleiro) AlguemGanhou() { meuTabuleiro.ganhou = true; As abstrações definidas pelo} programador, em Go, são monomórficas. Toda entidade tem um tipo específico associado.Println("---------------------------");Print("Linha: ");Println(posMaquina[0]+1);Print("Coluna: ");Println(posMaquina[1]+1); Mas, algumas abstraçõesPrintln("---------------------------"); embutidas (built-in) não são monomórficas. PLP - Linguagem Go 64
  • 65. Sobrecarga Go dá suporte a sobrecarga de operadores built-in. Entretanto, não dá suporte a sobrecarga de operaçoes. (Operadores: +, -, e outros)var barra string = "===== “;//...if (tabuleiro_jogo.IsZerou (jogador1.GetCor())){ Println(barra + "Jogador", jogador2.GetCor() + 1, "VENCEU! PARABÉNS", barra); break;}//... Para tipos da própria linguagem, um único identificador ou operador pode denotar diferentes abstrações. PLP - Linguagem Go 65
  • 66. Polimorfismo por Inclusão type Natural int; type Inteiro int; var x Natural = 1; var y Inteiro = -1; Println(x+y); //input.go:10: invalid operation: x + y (type Natural + Inteiro) Go não tem tipos que contenham subtipos que herdam operações aplicáveis a valores desses tipos. PLP - Linguagem Go 66
  • 67. Polimorfismo Paramétricofunc polimorfismoParametrico(a int64, b int64) { Println(a); Println(b);}func main() { var x int8 = 1; var y int8 = 2; polimorfismoParametrico(x, y);}//input.go:13: cannot use x (type int8) as type int64 in function argument//input.go:13: cannot use y (type int8) as type int64 in function argument Go não dá suporte a polimorfismo paramétrico. PLP - Linguagem Go 67
  • 68. Interfacepackage mainimport . "fmt";func main(){ jogador := new(Jogador); jogador.nome = "iza";  Go simula peca := new(Peca); peca.cor = "preto"; o uso de imprimir(jogador); imprimir(peca); interface} com o tipotype printer interface { Print(); } “interface”.func (p *Peca) Print() { Println(p.cor); }func (j *Jogador) Print() { Println(j.nome); }func imprimir (p printer) { p.Print(); }type Peca struct { cor string; }type Jogador struct { nome string; } PLP - Linguagem Go 68
  • 69. Coersãofunc Random(n int) int { sec, nsec, err := Time(); if err != nil { Seed(int64(n)); } else { Seed(int64(n)+(sec*1e9+nsec)); } return int(Int63n(int64(n)))} Não há mapeamento implícito de valores de um tipo para valores de um outro tipo. Em substituição às coerções, são adotados casts. PLP - Linguagem Go 69
  • 70. Sequenciadores
  • 71. Sequenciadores Desvios Incondicionais Escapes Exceções PLP - Linguagem Go 71
  • 72. Desvios Incondicionais I: Println(“Digite a dimensao: (N)"); var tam int = ReadInt(); if ( tam < 20 && tam > 4) { goto L; } Println(“N fora do limite [4,20]."); goto I; L: geraTabuleiro(tam); Para fazer Desvios Incondicionais usamos a palavra reservada “goto”  Só podemos fazer desvios incondicionais dentro do escopo da abstração de função. (Não podemos ir para pontos mais externos do programa). PLP - Linguagem Go 72
  • 73. Escapefor i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { Iteração afetada if (tabuleiro[i][j] == 9) { pelo escape Println("Achou bomba na linha ", i+1); break; } }}  Go dá suporte a escape através da palavra reservada“break” e “continue”.  Escape não rotulado apenas finaliza a iteração corrente. PLP - Linguagem Go 73
  • 74. Escape rotulado busca: for i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { if (tabuleiro[i][j] == 9) { Println("Achou bomba na linha ", i+1); break busca; } } } Rótulo  Go dá suporte a escape rotulado através da palavra reservada break mais o rótulo. PLP - Linguagem Go 74
  • 75. Exceções  Go não dá suporte a exceções. PLP - Linguagem Go 75
  • 76. Concorrência
  • 77. Concorrênciavar canal = make(chan int);func main() { go rotina1(); go rotina2(); Channel}func rotina1(){ Goroutines var i int = 0; for i = 0; i <= 100; i++ {  Go dá suporte a concorrência canal <- i; através de goroutines. }}  A comunicação entre osfunc rotina2(){ processos concorrentes é for { através de channel. msg := <- canal; Println(msg); if(msg == 100){ break; } }} PLP - Linguagem Go 77
  • 78. Spin-Lockfunc acquire(){ for(usandoRecurso){ } usandoRecurso = true; Flag}func relinquish(){ usandoRecurso = false;}  O flag é uma variável global.  Assim permitimos que apenas umafunc rotina1(){ acquire(); rotina tenha acesso ao recurso. //regiao critica relinquish(); Rotinas}func rotina2(){ acquire(); //regiao critica relinquish();} PLP - Linguagem Go 78
  • 79. Conclusão
  • 80. PLP - Linguagem Go 80
  • 81. PLP - Linguagem Go 81
  • 82. Referências
  • 83. Referências http://alovasconcelos.net/ http://golang.org http://tutorial.danielmazza.info/go RAMALHO, Franklin. Notas de Aula da disciplina Paradigmas de Linguagens de Programação, 2010. http://forum.zwame.pt/showthread.php?t=348920 PLP - Linguagem Go 83