Linguagem Go

Paradigmas de Linguagens de

Programação

Delano Oliveira

Janderson Jason

Luan Barbosa

Natã Melo

{delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br

Agenda

Introdução

Valores e Tipos

Armazenamento

Associações

Abstrações

Unidades de Programa

Sistemas de Tipos

Sequenciadores

Concorrência

Conclusão

PLP - Linguagem Go2

Introdução

Introdução

Motivação

Sintaxe e Semântica

Processador da Linguagem

Outras Características

PLP - Linguagem Go4

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 Go5

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 Go6

Processador da Linguagem

PLP - Linguagem Go7

Código Fonte *.8 ou *.6 Executável

Compilador: gccgo

(6g, 6l, 8g, 8l)

Outras Características

Criada pela Google e lançada em novembro de

2009

Equipe: Robert Griesemer, Rob Pike e Ken

Thompson

PLP - Linguagem Go8

Valores & Tipos

Valores & Tipos

Valores

Boolean

Numérico

String

Array

Struct

Ponteiros

Abstração de função e

procedimento

Mapa

Channel

Tipos

Primitivos

Compostos

Recursivo

Checagem de Tipos

Equivalência de Tipos

Princípio da Completude

Expressões

PLP - Linguagem Go10

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

}

Valores

PLP - Linguagem Go11

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.

Valores

PLP - Linguagem Go12

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.

Abstração de FunçãoNúmericos

BooleanosAbstração de Procedimento Ponteiro

Arrays

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

}

Tipos Primitivos

PLP - Linguagem Go13

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

var barra string = "===== “

var contagemEmpate int = 0

var travou bool = false

var porcentagem float = 10.5

Tipos Compostos

PLP - Linguagem Go14

type Tabuleiro struct {

matriz [8] [8] *Peca

int totalPecas

}

Struct – Sequência de elementos.

Campos: possuem nome e tipo.

Produtos Cartesianos : Structs

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.

Tipos Compostos

PLP - Linguagem Go15

Struct – Sequência de elementos.

Campos: possuem nome e tipo.

Produtos Cartesianos : Structs

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.

[][]*Peca x inttype Tabuleiro struct {

matriz [8] [8] *Peca

int totalPecas

}

type Tabuleiro struct {

matriz [8] [8] *Peca

int totalPecas

}

Tipos Compostos

Tipos Recursivos: Structs

Go não dá suporte:

União Disjunta

Conjuntos Potência

PLP - Linguagem Go16

Implementados através de ponteiros.

type Node struct {

valor Tupla

next *Node

}

Checagem de Tipos

Go é estaticamente e fortemente tipada.

PLP - Linguagem Go17

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 (){

dez_decimal := 10.0

var dez int = dez_decimal

}

prog.go:6: cannot use dez_decimal (type

float) as type int in assignment

FortementeErro ao tentar

compilar!!!

Equivalência de Tipos

Go dá suporte a equivalência nominal

PLP - Linguagem Go18

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)

tupla.EhDama()

}

prog.go:15: tupla.EhDama undefined

(type Tupla has no field EhDama)

Erro ao tentar

compilar!!!

Go não dá suporte a equivalência estrutural!

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.

PLP - Linguagem Go19

func (tabuleiro *Tabuleiro) IsZerou (cor int) bool

if (…){

return false

}

return true

}

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 Go20

Armazenamento

Armazenamento

Variáveis e Atualização

Arrays

Semântica de Cópia x

Semântica de Referência

Variáveis

Locais e Globais

Heap

Persistentes

Tipos de Comandos

Skip

Atribuição

Chamada de

procedimento

Comandos

Sequencial

Colateral

Condicional

Expressões com Efeitos

Colaterais

PLP - Linguagem Go22

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 Go23

Variáveis e Atualização

Go dá suporte a atualização seletiva e atualização

total

PLP - Linguagem Go24

Seletiva

Total

var posicaoFinal Coordenada;

posicaoFinal.x = 1;

posicaoFinal.y = 2;

var posicaoInicial Coordenada;

posicaoInicial = posicaoFinal;

Arrays

PLP - Linguagem Go25

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;

}

Semântica de Cópia x

Semântica de Referência

PLP - Linguagem Go26

Por Referência

Por Cópia

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;

posicao2 = &posicao1;

posicao3 = posicao2;

posicao3.x = 5;

posicao3.y = 5;

Variáveis Locais e Globais

PLP - Linguagem Go27

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”

func main() {

tamanho := 10;

if (...){

var numBombas = 15;

}

}

Variável Global

Variáveis LocaisAçúcar

Sintático

Variáveis Heap

PLP - Linguagem Go28

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.

var tabuleiro_jogo *Tabuleiro = new (Tabuleiro)

Alocação de

memória

Variáveis persistentes

PLP - Linguagem Go29

oldfile := "text.txt"

newfile := "text2.txt"

doc, _ := ioutil.ReadFile(oldfile)

ioutil.WriteFile(newfile,doc,0644)

São do tipo “File”

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++

Skip e Atribuição

PLP - Linguagem Go30

Não há atribuição múltipla em Go.

Skip e Atribuição

PLP - Linguagem Go31

Skip usado para separar expressões

Não há atribuição múltipla em Go.

Atribuição simultâneaAçúcar sintático

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++

Atribuição

Chamada de Procedimentos

PLP - Linguagem Go32

Chamada de procedimento

Procedimento

peca := new (Peca)

peca.SetCor(Preto)

//...

func (peca *Peca) SetCor (cor int) {

peca.cor = cor

}

Comando Sequencial

PLP - Linguagem Go33

meuTabuleiro.n = 0

meuTabuleiro.m = 0

meuTabuleiro.ganhou = false

Comando Colateral Não existem comandos colaterais.

meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false;

Separados por ponto-e-vírgula,

ou por quebra de linha.

Comando Condicional

PLP - Linguagem Go34

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"

}

Comandos Iterativos

PLP - Linguagem Go35

for i > 0 {

var a int = Random(n);

var b int = Random(n);

//...

}

for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS;

i++ {

nodeAtual = new(Node);

nodeAtual.SetValor(tuplaAtual);

//...

}

Iteração definida

Iteração indefinidaPalavra reservada for

funcionando como o comando while em

outras linguagens.

Associações

Associações

Entidades Associáveis

Escopo

Estrutura de Blocos

Visibilidade

Declarações

Definição

Declaração de Tipo

Declaração de Variável

Declarações Colaterais

Declarações Sequenciais

Declarações Recursivas

Comando Bloco

Expressão Bloco

Princípio da Qualificação

PLP - Linguagem Go37

Entidades Associáveis

PLP - Linguagem Go38

meuTabuleiro.m = 0;

meuTabuleiro.ganhou = false;

var Numero int = calculaNumDeMinas(n);

const( MAX_MOVIMENTOS int = 50);

Valores primitivos e compostos

Abstrações de funções e procedimentos

Variáveis e Tipos

Escopo

Em Go, o corpo de um bloco é avaliado no

ambiente em que foi definido (associação

estática).

PLP - Linguagem Go39

const s = 2;

func incremento ( d int ) int {

return d∗s;}

func executaIncremento ( valor int ) int {

const s = 3;

return incremento ( valor );

}

func main () {

fmt.Println( executaIncremento(5) );

}

Saída: 10

Blocos: Estrutura e Visibilidade

PLP - Linguagem Go40

var tamanhoTabuleiro int = 10;

for {

var tamanhoTabuleiro = 15;

for {

var tamanhoTabuleiro = 20;

fmt.Println( tamanhoTabuleiro );

break;

}

fmt.Println( tamanhoTabuleiro ) ;

break;

}

fmt.Println( tamanhoTabuleiro );

imprime 20

imprime 15

imprime 10

Estrutura: blocos aninhados.

Visibilidade: variáveis declaradas em blocos

de escopo internos não são visíveis a blocos

de escopo externos.

Definição

PLP - Linguagem Go41

const( MAX_MOVIMENTOS int = 50)

func Jogada() (int,int) {

//…

}

var posJogada;

var posX *int;

var posAux *int;

As definições em Go podem ser de tipo, abstração

de funções, abstração de procedimentos, variáveis,

constantes.

Constante

Abstração de função

Variáveis

Declaração de Tipo

PLP - Linguagem Go42

type Peca struct {

cor int;

dama bool;

}

Declaração de Variável

var vertical string = "Coordenada Vertical: “;

var valor int = 1;

var decimal float = 1.0;

Go dá suporte a declaração de tipos

através da palavra reservada type.

O tipo Peca sendo declarado.

Como a maioria das linguagens imperativas,

Go dá suporte à declaração sequencial.

Declaração sequencial

PLP - Linguagem Go43

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.

Go dá suporte a declaração recursiva.

Declaração recursiva

PLP - Linguagem Go44

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

Comando bloco

PLP - Linguagem Go45

Go dá suporte a comando bloco.

Declaração que é usada apenas pra executar o comando

func ( pilha ∗Node ) PrintValorProximo( ) {

Println ( "|" , pilha.GetValor( ) , "|" );

next := pilha.GetNext( );

Println(next.GetValor());

}

Expressão bloco

func (peca *Peca) GetValue(peca2 *Peca)(bool){

valor1 := peca.EhDama()

valor2 := peca2.EhDama()

return valor1 && valor2

}

PLP - Linguagem Go46

Go dá suporte a expressão bloco.

Declarações usadas apenas para avaliar a expressão.

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.

PLP - Linguagem Go47

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.

Abstrações

Abstrações

Tipos de Abstrações

Abstração de Função

Abstração de

Procedimento

Princípio da Abstração

Parâmetros

Argumentos

Passagem de Parâmetros

Princípio da

Correspondência

Ordem de Avaliação

PLP - Linguagem Go49

Abstração de Função

PLP - Linguagem Go 50

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;

}

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.

Abstração de Procedimento

PLP - Linguagem Go51

func inicializarJogo() {

tabuleiro.ReiniciaTabuleiro();

ehHumano = true;

}

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.

Princípio da abstração

PLP - Linguagem Go52

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.

Parâmetros

PLP - Linguagem Go53

type Peca struct {

cor int

dama bool

}

func (peca *Peca) EhDama () (bool){

return peca.dama

}

Como Go é fortemente tipada, os parâmetros devem possuir

tipos definidos.

Podem ser de qualquer tipo.

Passagem de Parâmetros

PLP - Linguagem Go54

Em Go a passagem de parâmetros é por cópia\valor.

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

Princípio da Correspondência

PLP - Linguagem Go55

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

Ordem de Avaliação

PLP - Linguagem Go56

Eager Evaluation

var p int;

func main () {

p = 3;

print ( p )

}

func print ( n int ) {

Println(n);

p = 100;

Println(n);

}

Saída:

3

3

Unidades de Programa

Unidades de Programa

Pacotes

Tipos Abstratos de Dados

Objetos e Classes

Unidades Genéricas

PLP - Linguagem Go58

Pacotes

PLP - Linguagem Go59

package tabuleiro

//...

func (meuTabuleiro *Tabuleiro) Ganhou() bool {

return meuTabuleiro.ganhou;

}

func (meuTabuleiro *Tabuleiro) AlguemGanhou(){

meuTabuleiro.ganhou = true;

}

func calculaNumDeMinas(tamanho int) int{

//...

return numeroDeBombas;

}/

Função com

visibilidade privada

Funções visíveis

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.

Tipo Abstrato de Dados

PLP - Linguagem Go60

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)

}

//...

Objetos e Classes

PLP - Linguagem Go61

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.

Go não tem Objetos e Classes, porém, simula-os através de

structs e funções ligadas a esses tipos.

Sistemas de Tipos

Sistema de Tipos

Monomorfismo

Sobrecarga

Polimorfismo Paramétrico

Polimorfismo por Inclusão

Interfaces

Coerção

PLP - Linguagem Go63

func (meuTabuleiro *Tabuleiro) Ganhou() bool{

return meuTabuleiro.ganhou;

}

func (meuTabuleiro *Tabuleiro) AlguemGanhou() {

meuTabuleiro.ganhou = true;

}

Println("---------------------------");

Print("Linha: ");

Println(posMaquina[0]+1);

Print("Coluna: ");

Println(posMaquina[1]+1);

Println("---------------------------");

Monomorfismo

PLP - Linguagem Go64

As abstrações definidas pelo

programador, em Go, são

monomórficas. Toda

entidade tem um tipo

específico associado.

Mas, algumas abstrações

embutidas (built-in) não

são monomórficas.

Sobrecarga

PLP - Linguagem Go65

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.

Go dá suporte a sobrecarga de operadores built-in.

Entretanto, não dá suporte a sobrecarga de operaçoes.

(Operadores: +, -, e outros)

Polimorfismo por Inclusão

PLP - Linguagem Go66

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.

Polimorfismo Paramétrico

PLP - Linguagem Go67

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.

Interface

PLP - Linguagem Go68

package main

import . "fmt";

func main(){

jogador := new(Jogador);

jogador.nome = "iza";

peca := new(Peca);

peca.cor = "preto";

imprimir(jogador);

imprimir(peca);

}

type printer interface { Print(); }

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; }

Go simula

o uso de

interface

com o tipo

“interface”.

Coersão

PLP - Linguagem Go69

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.

Sequenciadores

Sequenciadores

Desvios Incondicionais

Escapes

Exceções

PLP - Linguagem Go71

Desvios Incondicionais

PLP - Linguagem Go72

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).

Escape

PLP - Linguagem Go73

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;

}

}

}

Iteração afetada

pelo escape

Go dá suporte a escape através da palavra

reservada“break” e “continue”.

Escape não rotulado apenas finaliza a iteração

corrente.

Escape rotulado

PLP - Linguagem Go74

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;

}

}

}

Go dá suporte a escape rotulado através da

palavra reservada break mais o rótulo.

Rótulo

Exceções

PLP - Linguagem Go75

Go não dá suporte a exceções.

Concorrência

Concorrência

PLP - Linguagem Go77

var canal = make(chan int);

func main() {

go rotina1();

go rotina2();

}

func rotina1(){

var i int = 0;

for i = 0; i <= 100; i++ {

canal <- i;

}

}

func rotina2(){

for {

msg := <- canal;

Println(msg);

if(msg == 100){

break;

}

}

}

Go dá suporte a concorrência

através de goroutines.

A comunicação entre os

processos concorrentes é

através de channel.

Goroutines

Channel

Spin-Lock

PLP - Linguagem Go78

func acquire(){

for(usandoRecurso){

}

usandoRecurso = true;

}

func relinquish(){

usandoRecurso = false;

}

func rotina1(){

acquire();

//regiao critica

relinquish();

}

func rotina2(){

acquire();

//regiao critica

relinquish();

}

Flag

Rotinas

O flag é uma variável global.

Assim permitimos que apenas uma

rotina tenha acesso ao recurso.

Conclusão

PLP - Linguagem Go80

PLP - Linguagem Go81

Referências

Referências

PLP - Linguagem Go83

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