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 Locais
Sintá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 = false
Comando 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íveis
func (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. Monomorfismo
func (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ções
Println("---------------------------"); 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étrico
func 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. Interface
package main
import . "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 tipo
type 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ão
func 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. Escape
for 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ência
var 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 os
func rotina2(){ processos concorrentes é
for { através de channel.
msg := <- canal;
Println(msg);
if(msg == 100){
break;
}
}
}
PLP - Linguagem Go
77

78. Spin-Lock
func acquire(){
for(usandoRecurso){
}
usandoRecurso = true;
Flag
}
func relinquish(){
usandoRecurso = false;
}  O flag é uma variável global.
 Assim permitimos que apenas uma
func 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