Olá! Tudo bem? Conseguiu instalar o Portugol Studio e executar seu primeiro programa? Espero que sim! Hoje, nós vamos desvendar a estrutura de um programa usando o código visto no artigo anterior e fazer mais alguns exercícios, ok? Vamos lá!

Antes de tudo, para começarmos a entender como escrever novos programas, é interessante compreendermos o que é uma linguagem. Uma linguagem é um conjunto de elementos como palavras e símbolos que, quando combinados segundo algumas regras, são usados para comunicar ideias. Já havíamos visto esse ponto de comunicar ideias quando falamos sobre representação de algoritmos. A questão, agora, é conhecer esses elementos e as regras pelas quais podemos juntá-los para criarmos programas.

Vejamos a Língua Portuguesa: ela é formada por um monte de palavras que chamamos de vocabulário e por algumas regras que chamamos de sintaxe (você lembra que fazia análise sintática 😮 no colégio?). Se não me falha a memória, para formarmos uma frase precisamos de um sujeito e de um predicado sendo, este último, formado por um verbo e, dependendo do caso, seus objetos diretos e indiretos. Uau! 🙂 Então, numa linguagem de programação como o Portugol, também temos um vocabulário. Existem certas palavras que o compilador ou o interpretador consegue entender como “programa”, “funcao”, “se”, “senao”, entre outras. Nós as chamamos de palavras reservadas. E, claro, existem algumas regras para que você junte essas palavras reservadas com símbolos e outras palavras para indicar uma instrução que você quer que o computador execute.

E, você lembra da época do colégio como se faz para escrever uma redação de carta? Lembra que há uma certa estrutura? Primeiro vem a data, depois uma saudação, depois o texto e, por último uma assinatura. E, que dentro do texto devemos ter um começo, um meio e um fim? Pois bem, quando vamos escrever um programa, ele também tem uma sequência que deve ser seguida. Vamos rever o código do programa “Olá, Mundo!”:

[code]
programa
{
funcao inicio()
{
escreva("Olá, mundo!")
}
}
[/code]

Notou como é a estrutura de um programa em Portugol? Não? Vamos destrinchá-lo? Bom, primeiramente, o seu código deve começar com a palavra reservada “programa” seguida de “{“, seguida de uma ou mais funções e, para terminar, “}”. Os símbolos “{” e “}” delimitam o que chamamos de bloco de código. Observe:

[code]
programa
{
…
}
[/code]

Esse é o bloco de código que é o nosso programa. No lugar das reticências, devem vir funções (já, já explico o que são). Mas, como se faz para criar uma função? Fácil: é a palavra reservada “funcao”, seguida do nome que você quer dar para a função (o qual chamamos de identificador), seguido de “(“, seguido de “)”, seguido de “{“, seguido de uma lista de comandos, seguidos de “}”. Ou seja:

[code]
funcao identificador()
{
…
}
[/code]

Com isso, você acabou de ver duas regras: uma para criar o programa e outra para criar uma função. A gente chama isso de sintaxe. Se alguém te perguntar “Qual é a sintaxe para criar uma função em Portugol?” você já sabe responder!

Uma das grandes habilidades de um programador é conseguir saber essas regras e usá-las onde são necessárias. Ou seja, se temos um bloco de código do programa assim:

[code]
programa
{
// aqui você deve colocar uma função
}
[/code]

Um programador pensaria assim: “Hum… Ali devemos colocar uma função… Fácil! Eu sei a sintaxe! Vou criar uma função chamada inicio.” e escreveria um código assim:

[code]
programa
{
funcao inicio()
{
// aqui você deve colocar os comandos que você quer que o computador execute
}
}
[/code]

Agora, o programador veria que, dentro do bloco de código da função, deve colocar comandos. Aí, ele vai pensar qual comando ele quer e se lembrar da sintaxe. Ou seja, um programador tem, em sua cabeça, um repertório de comandos que ele pode usar bem como as sintaxes desses comandos. Veja que se ele quer que o computador mostre a mensagem “Olá, mundo!”, ele deve lembrar que o comando é “escreva” seguido de “(” seguido da mensagem seguida de “)”. Assim, ele terminaria com o código visto no artigo anterior:

[code]
programa
{
funcao inicio()
{
escreva("Olá, mundo!")
}
}
[/code]

Indentação

Um ponto importante de se observar é que os espaços em branco são irrelevantes para o compilador ou interpretador, mas fazem uma grande diferença para nós, humanos, que estamos lendo o código. Olha só:

[code]
programa { funcao inicio() { escreva("Olá, mundo!") } }
[/code]

Esse é o mesmo programa anterior, mas sem os espaços. Fica mais complicado de entender, não? Chamamos de indentação o ato de alinhar os blocos usando espaços em branco. Eles são muito importantes para facilitar a leitura e entendimento de um código e é considerada uma boa prática de programação!

Comentários

Outra prática que facilita o entendimento de um código é colocar comentários nas partes que precisam de alguma explicação. Comentários são textos que o Portugol Studio irá ignorar. Eles servem apenas para nós, humanos.

Para criar um comentário de uma linha, basta colocar “//” seguido do texto que é o seu comentário. Caso você precise escrever muito texto, aí use o comentário multilinhas. Ele é feito com a seguinte sintaxe: “/*” seguido do texto que pode estar em várias linhas seguido de “*/”. Exemplos:

[code]
/*
* Esse é o primeiro programa que costumamos escrever.
* O resultado dele é mostrar o texto "Olá, mundo!" na tela!
*/
programa
{ // início do programa
funcao /* principal */ inicio()
{ // inicio da função
// a função escreva mostra uma mensagem na tela
escreva("Olá, mundo!")
} // fim da função
} /* fim do programa */
[/code]

Note que esse código está com exagero de comentários. Não faça isso nos seus programas! 😉 Como você deve ter percebido, o que era para ajudar no entendimento do programa, acabou dificultando sua leitura!

Funções

Eu estou me adiantando um pouco ao te explicar agora o que é uma função, mas, inicialmente, podemos entendê-las como sendo algoritmos. Simples! Só isso! No nosso caso, a função que chamamos de “inicio” é o algoritmo que será executado. Chamamos, então, essa função de função principal.

As funções exercem um papel fundamental na programação e iremos aprendê-las mais para frente. Para entender o quão fundamental é esse papel, basta perceber que o comando “escreva” é, na verdade, uma função. Só que, como você deve ter percebido, não fomos nós que a criamos. Quem a criou foram os programadores do Portugol Studio e eles a deixaram disponível para que nós pudéssemos usá-la! Ela é o que chamamos de função pré-definida. O Portugol Studio tem um monte delas e nós iremos conhecê-las no decorrer das aulas.

Mensagens

Agora que você já sabe como é a estrutura de um programa escrito em Portugol e já conhece uma função pré-definida que permite você escrever mensagens, você poderá treinar com os exercícios que coloquei no fim deste artigo. Só que não! 🙂 Antes, preciso te dizer mais alguns detalhes…

Você lembra que a sintaxe para executar essa função pré-definida era “escreva” seguido de “(” seguido da mensagem seguida de “)”? Só que eu não disse como que faz para colocar a mensagem!!! A regra, a sintaxe é “aspas” seguida do texto seguido de “aspas”, conforme você pode ver abaixo:

[code]"Olá, mundo!"[/code]

Talvez você tenha se perguntado: “Como faço para colocar uma aspas dentro do texto, uma vez que as aspas indicam o começo e o fim de mensagem?” Essa é uma excelente pergunta! Para fazer isso, é necessário usar uma sequência de escape. Apesar do nome “maluco”, não é nada mais que colocar o símbolo “\” na frente de aspas, assim:

[code]"Olá, \"mundo\"!"[/code]

Irá mostrar: Olá, “mundo”!

Outra sequência de escape é a indicação de “nova linha”. Para isso, use “\n” no seu texto, assim:

[code]"Olá,\nmundo!"[/code]

Irá mostrar: Olá,
mundo!

Erros de Sintaxe

Outro detalhe é saber que, às vezes, acabamos errando algo no nosso programa que fere as regras, a sintaxe da linguagem que estamos usando (Portugol, no nosse caso). Esses erros são chamados de erros de sintaxe. Um exemplo seria colocar “apóstrofo” no lugar de “aspas” ao indicar a mensagem que você quer que o computador escreva na tela:

[code]
programa
{
funcao inicio()
{
escreva(‘Olá, mundo!’)
}
}
[/code]

Esse programa não vai funcionar e o Portugol Studio vai te falar isso:

Hummm… A mensagem nem sempre é clara! Vá se acostumando! 😉 Mas, há uma indicação que na linha 5 há um erro! Vai lá e arruma, ô meu!

Vários são os erros sintáticos: esquecer de fechar uma chave “}” ou um parêntese “)”, errar uma palavra chave como colocar “função” com cedilha ao invés de “funcao”. Aliás, se atente a esses detalhes! Em linguagens “comerciais”, por assim dizer, o número de detalhes aumenta e é bom você ir treinando desde já! Dica: evite identificadores com acentos (caso tenha passado despercebido lá em cima, identificadores são os nomes que você dá para as funções).

Erros de Lógica

Existe uma outra categoria de erro, mais “cruel”, chamada de erro de lógica ou bug. Esse erro é causado quando o programador pede para o computador executar o programa, mas o resultado não é o esperado! Oras, por quê isso iria ocorrer? Será que o computador está de birra e executou outra coisa? Na verdade, o computador faz exatamente aquilo que o instruirmos a fazer! E, é aí que “mora o perigo”. Se o programador se “distrair” e escrever um programa logicamente errado, o computador não tem como saber! Por isso que esse tipo de erro é “cruel”. Erros de sintaxe impedem o computador de ler seu programa. Erros de lógica, não! Você só saberá que eles existem executando seu programa e testando ele. Exemplo: o programa abaixo não irá escrever a mensagem que queremos… 🙁

[code]
programa
{
funcao inicio()
{
escreva("mundo!")
escreva("Olá, ")
}
}
[/code]

Algumas técnicas podem ser usadas para minimizar a ocorrência desses erros. Uma muito usada é chamada de teste de mesa. Ela consiste em verificarmos à mão, passo-a-passo, a execução do programa. Em breve, iremos usá-la em nossos programas. Aguardem!

Conclusão

Nesta aula, você viu como é a estrutura básica de um programa e aprendeu que existem certas regras que devem ser seguidas para que o Portugol Studio consiga entender seu código. Além disso, aprendeu sobre blocos de código, identificadores, indentação, funções e erros de sintaxe e de lógica. Você deve ter percebido que os erros de lógica têm a ver com lógica de programação, ou seja, você precisa aprender a escrever os comandos na sequência que gere o resultado esperado. Não tente, por exemplo, colocar a meia depois de calçar o sapato! 😉

Aliás, isso é uma dica muito importante (não, não a do sapato!): uma vez que você tenha aprendido lógica de programação com o Portugol, você pode aprender novas linguagens apenas aprendendo sua sintaxe. O restante muda muito pouco! Você vai ver…

Bom, agora é treinar, treinar e treinar. Logo abaixo você encontra alguns exercícios propostos. Mas, não se limite a eles. “Brinque” com seu código. Experimente criar um erro de sintaxe propositadamente. Verifique qual a mensagem que o Portugol Studio te mostra. Tente outras mensagens. Tenha dúvidas! TENHA DÚVIDAS! E, coloque-as nos comentários abaixo e vamos interagir! Até a próxima aula.

Exercícios

Até agora, você só aprendeu o comando, a função “escreva”. Nós voltaremos com mais detalhes sobre ela em breve. Por enquanto, tenha em mente que você deve ficar craque na criação de mensagens. Você deve conseguir fazer isso de olhos vendados, com as mãos amarradas usando apenas o pensamento! Não estou brincando! 😉 Mas, sério, domine a arte de mandar o computador escrever as mensagens o mais próximo possível do que foi pedido pelo exercício (ou pelo seu cliente!).

Exercício 1

Escreva um programa que mostre o seguinte formulário na tela:

    Nome: Maria José 
   Idade: 28 anos
Telefone: (11) 9.5555-5555
     Rua: Rua dos Bobos
  Número: Zero
     CEP: 12345-678

Exercício 2

Escreva um programa que mostre um tabuleiro de xadrez na tela (use “#” para preenchimento):

+----------------+
|  ##  ##  ##  ##|
|##  ##  ##  ##  |
|  ##  ##  ##  ##|
|##  ##  ##  ##  |
|  ##  ##  ##  ##|
|##  ##  ##  ##  |
|  ##  ##  ##  ##|
|##  ##  ##  ##  |
+----------------+

Exercício 3

Escreva um programa que mostre um tabuleiro de jogo-da-velha na tela:

 X | O |
---+---+---
   | X |   
---+---+---
   |   | O

Exercício 4

Escreva um programa que mostre a seguinte tabela na tela:

% de aumento |  2010 |  2011
-------------+-------+-------
     Marca A |  4.5% |  7.5%
     Marca B | 14.5% | 23.5%

Exercício 5 (desafio)

Escreva um programa que mostre o seguinte QR-Code na tela (use # para os “quadradinhos”):