No final desta lição, você terá a chance de realmente começar a escrever um código simples, e não apenas editar algo que já existe!

Mas primeiro, um pouco mais de informação.

O que bons programadores fazem (em vez de só lembrarem)

Um programador experiente faz anotações no código, que não fazem parte do programa, mas são comentários sobre o que fizeram ou por que o fizeram. Quando o programa é executado, esses comentários são ignorados, mas as notas do programador, chamadas de comentários de código ou apenas comentários, permanecem no código.

Comentários de código

Escrever comentários de código é uma boa prática em geral, mas é especialmente útil quando você ainda está começando a programar e descobrindo as coisas à medida que avança. Esses comentários podem ser muito úteis quando você tenta entender por que você (ou outra pessoa) fez algo.

A maneira mais simples de escrever um comentário de código é colocar um # na frente do comentário, mas também existem outras maneiras de fazê-lo:

1+2 # Olá
Copy full snippet

Copy full snippet

Copy full snippet

Como usar condicionais para tomar decisões no código

Você se lembra daquelas expressões if .. else que você viu na Aula 2? Elas são conhecidas como expressões condicionais.

Expressões condicionais, ou condicionais, são como você orienta seu programa a tomar decisões.

A expressão if está testando se algo foi bem-sucedido ou falhou. Determinado código poderá ser executado se for bem-sucedido. Se falhar, outro código será executado em seu lugar.

Você pode pensar nisso como uma forma de fazer uma pergunta de sim ou não ao seu programa.

Na vida real, você toma decisões o tempo todo com base na resposta a uma pergunta de sim ou não. Por exemplo, você está com sono? Se a resposta for sim, você vai dormir. Se a resposta for não (else), em vez de dormir, você vai assistir a desenhos animados.

Se você fosse programar esse comportamento, ele poderia se parecer com:

~~~(verse) var Tired: logic = false var WhatToWatch: string = "nothing"

if (Tired?): set WhatToWatch = "suas pálpebras" else: set WhatToWatch = "assistir a desenhos animados"

Print("Você deve assistir a {WhatToWatch}")

Você deve assistir a desenhos animados

![If tired go to sleep, else watch cartoons](https://d1iv7db44yhgxn.cloudfront.net/documentation/images/9cb79f70-114b-4d7c-91f6-e1f9378b836a/tired-else-tv.png){:width="800"}

Você notou aquele ponto de interrogação `?` na expressão `if`? É assim que um programa Verse verifica se um tipo `logic` é `true` ou `false`.

### Aninhamento

Quando o código é **aninhado**, significa que ele está recuado sob uma expressão de palavra-chave como `if` ou `else`. Essas expressões criam um novo escopo.

Escopo refere-se a um pedaço de código onde nomes e seus valores associados podem ser usados. O escopo está contido em um bloco de código recuado.

Por exemplo: 

        ~~~(verse)
if (Tired?):
	set WhatToWatch = "suas pálpebras"
else:
	set WhatToWatch = "assistir a desenhos animados"
Copy full snippet

A linha set WhatToWatch = "ir dormir" é recuada sob a linha if (Tired?):. O mesmo padrão se repete para a linha else:.

Você pode aninhar uma única linha de código ou um bloco (várias linhas) de código.

Isso significa que, quando o código for executado, o código aninhado só será executado dentro do contexto do código sob o qual está aninhado.

Como usar várias condições

Às vezes, você precisa fazer mais que uma pergunta antes de tomar uma decisão. No Verse, isso é feito com os operadores and e or. Eles são chamados de operadores de decisão.

Ao usar and, as condições em ambos os lados do operador precisam ser verdadeiras ou bem-sucedidas para que toda a expressão seja bem-sucedida.

Ao usar or, apenas uma condição precisa ser verdadeira ou bem-sucedida para que toda a expressão seja bem-sucedida.

Para ver como esses operadores funcionam, vamos revisar o código.

Mesmo que você não esteja cansado, pode ser uma boa ideia dormir se tiver aula amanhã. Vamos verificar esse fato criando uma variável chamada SchoolTomorrow e usando or para verificar ambas as variáveis logic.

~~~(verse) var Tired: logic = false var SchoolTomorrow: logic = true var WhatToWatch: string = "nothing"

if (Tired? or SchoolTomorrow?): set WhatToWatch = "suas pálpebras" else: set WhatToWatch = "assistir a desenhos animados"

Print("Você deve assistir a {WhatToWatch}")

Você deve observar suas pálpebras

`Tired` ainda está definido como `false`, mas como `SchoolTomorrow` está definido como `true`, toda a expressão é bem-sucedida e `WhatToWatch` é definido como `"ir dormir"`.

**Há outra maneira de verificar várias condições.**

Usar `if` ... `else if` ... `else` coloca uma sequência nas coisas que você está verificando. Isso significa que, se você verificar a primeira condição, precisará verificar a próxima apenas se a condição anterior falhar. 

E se não houver aula amanhã e você não estiver cansado? Você pode querer ir ver um filme com seus amigos. Vamos revisar o código mais uma vez para ver como isso funciona.

Atualize o valor da variável `SchoolTomorrow` e declare uma nova variável, `FriendsAvailable`.

~~~(verse)
var FriendsAvailable: logic = true
set SchoolTomorrow = false
Copy full snippet

Em seguida, você atualizaria o código para verificar se seus amigos estão disponíveis, mas apenas se não estiver cansado ou não tiver aula amanhã.

~~~(verse) if (Tired? or SchoolTomorrow?): set WhatToWatch = "suas pálpebras" else if (FriendsAvailable?): set WhatToWatch = "assistir a um filme com os amigos" else: set WhatToWatch = "assistir a desenhos animados" ~~~

Perfeito! Agora você só vai dormir se estiver cansado ou tiver aula no outro dia. Se a resposta a qualquer uma das perguntas for não, você assistirá a um filme com seus amigos ou ficará em casa e assistirá a desenhos animados se seus amigos não estiverem disponíveis.

Planejar suas noites ficou muito mais fácil, graças ao Verse.

Solução de problemas

Lembra na Aula 1 quando você aprendeu sobre erros de compilador?

Outra coisa que você pode encontrar ao escrever código são bugs.

Bugs

Um bug é um erro em um programa de computador que faz com que ele produza um resultado incorreto ou inesperado. O efeito de um bug pode ser algo pequeno, como mudar a cor do texto em uma mensagem, ou algo mais dramático, como enviar a mensagem de texto para a tela na hora errada ou até mesmo causar o travamento do programa.

O termo foi popularizado por Grace Hopper, uma pioneira na ciência da computação, quando encontrou uma mariposa em um computador e a prendeu com fita no log de solução de problemas com um comentário que dizia “Primeiro caso real de um bug (inseto) sendo encontrado”.

Embora os erros do compilador impeçam a compilação de um programa, um bug não aparecerá até que o programa esteja em execução.

O processo de identificação e remoção de bugs é chamado de depuração, e uma ferramenta que ajuda a encontrar bugs é um depurador.

Resumo

• Use comentários de código para lembrar por que você escreveu o código de uma maneira específica e para ajudar outros programadores a entender o que você fez e por quê.
• Use constantes para valores que devem permanecer constantes ao longo do programa.
• Use variáveis para valores que devem mudar com base na entrada.
• Bugs e erros de compilação são causados por erros no código.

Chegou a hora de praticar!