# Referência de Programação em &logo; do &kturtle;

Esta é a referência para o &logo; do &kturtle;. Neste capítulo iremos tocar brevemente em todos os tipos de instruções diferentes. Depois, serão explicados os comandos, um por um. De seguida, serão explicados os contentores, a matemática, as questões e os controladores de execução. Por último, ser-lhe-á mostrado como criar os seus próprios comandos com o learn.

## Tipos Diferentes de Instruções

Como em qualquer linguagem, o LOGO tem diferentes tipos de palavras e símbolos. Aqui, será explicada a diferença entre os vários tipos.

### Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados introduzidos, enquanto outros trazem resultados.

    # o 'forward' é um comando que necessita de dados de entrada, neste caso o número 100:
    forward 100

Para uma ideia geral de todos os comandos que o &kturtle; suporta, venha aqui.

### Números

O mais provável é que você já conheça alguma coisa sobre os números. A forma como estes são usados no &kturtle; não é muito diferente da língua falada ou da matemática.

Temos então os números conhecidos por naturais: `0`, `1`, `2`, `3`, `4`, `5`, etc. Os números negativos: `-1`, `-2`, `-3`, etc. Finalmente, os números decimais ou fraccionários, como por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Os números podem ser usados em cálculos matemáticos e perguntas. Também podem ser colocados em contentores.

Os números ficam realçados a azul no editor de código.

### Cadeias de caracteres

Primeiro um exemplo:

    print "Olá, sou uma cadeia de caracteres."

Neste exemplo, o `print` é um comando, enquanto o `"Olá, sou uma cadeia de caracteres."` é, de facto, uma cadeia de caracteres. Estas começam e terminam com o símbolo `"`; com estes símbolos, o &kturtle; sabe que é uma cadeia de caracteres.

As cadeias de caracteres podem ser colocadas em contentores. Porém, não podem ser usadas em cálculos matemáticos nem em questões.

As cadeias de caracteres ficam realçadas a vermelho escura no editor de código.

### Nomes

Ao usar a linguagem de programação &logo;, pode criar coisas novas. Se criar um programa irá necessitar normalmente de contentores e, em alguns casos, do learn para criar novos comandos. Ao criar um contentor ou um novo comando com o learn, terá de indicar um nome.

Poderá escolher qualquer nome, desde que este não tenha já algum significado. Por exemplo, não poderá chamar a um contentor forward, dado que esse nome já é usado para um comando e, como tal, já tem um significado.

    # Aqui o forward é usado como contentor, mas já tem um significado
    # pelo que irá produzir um erro:
    forward = 20

    # isto funciona:
    forward 20

Os nomes só poderão conter letras, números e sublinhados (_). De qualquer forma, têm de começar por uma letra.

Por favor, leia a documentação sobre os contentores e o comando learn para uma melhor explicação e mais exemplos.

### Atribuições

As atribuições são feitas com o símbolo `=`. Nas linguagens de programação é melhor ler o `=` simples não como um 'é igual a' mas sim como um 'fica igual a'. O termo 'é igual a' é mais apropriado para o `==`, que é uma pergunta.

As atribuições são usadas normalmente por duas razões, (1) para adicionar conteúdo aos contentores e (2) para modificar o conteúdo de um contentor. Por exemplo:

    x = 10
    # o contentor 'x' contém agora o número 10
    W = "A minha idade é: "
    # o contentor W contém agora o texto "A minha idade: "
    # isto imprime o conteúdo dos contentores 'W' e 'x' na área de desenho
    print W + x

Para mais exemplos, veja a secção que explica os contentores.

### Símbolos Matemáticos

O &kturtle; suporta todos os símbolos matemáticos básicos: a adição (`+`), a subtracção (`-`), a multiplicação (`*`), a divisão (`/`) e os parêntesis `(` e `)`.

Para uma explicação completa e mais exemplos, veja a secção de matemática.

### Perguntas

Podem ser feitas algumas perguntas simples, onde nesse caso a resposta será 'true' (verdadeira) ou 'false' (falsa).

A utilização das perguntas é explicada de forma extensa na secção de perguntas.

### Palavras de Colagem de Perguntas

As perguntas podem ser coladas em conjunto com o que se denomina por 'cola das perguntas'. As palavras de colagem são o `and` (e), o `or` (ou) e uma palavra especial: a `not` (não).

A utilização da colagem de perguntas é explicada na secção de Colagem de Perguntas.

### Comentários

Os comentários são linhas que começam por um `#`. Por exemplo:

    # isto é um comentário!
    print "isto não é um comentário"
    # a linha anterior não é um comentário, mas a próxima é:
    # print "isto não é um comentário"

Nas linhas comentadas, poderão ser adicionadas notas ao código, para nós ou para outra pessoa ler. Os comentários são usados para: (1) adicionar uma pequena descrição ao programa, (2) para explicar como é que funciona um determinado excerto de código se este for ligeiramente complicado e (3) para 'desactivar' linhas de código que deverão ser (temporariamente) ignoradas (veja a última linha do exemplo).

As linhas comentadas ficam realçadas com um amarelo escuro no editor de código.

## Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados introduzidos, enquanto outros trazem resultados. Nesta secção iremos explicar todos os comandos que podem ser usados no &kturtle;. Repare que todos os comandos incorporados ficam realçados a verde escuro no editor de código, para que possa ajudar a distingui-los.

### Mover a tartaruga

Existem vários comandos para mover a tartaruga pelo ecrã.

#### forward (fw)

forward

-     forward X

  O `forward` move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `forward` pode ser abreviado para `fw`

#### backward (bw)

backward

-     backward X

  O `backward` move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `backward` pode ser abreviado para `bw`.

#### turnleft (tl)

turnleft

-     turnleft X

  O `turnleft` diz à tartaruga para se virar X graus para a esquerda. O `turnleft` pode ser abreviado para `tl`.

#### turnright (tr)

turnright

-     turnright X

  O `turnright` diz à tartaruga para se virar X graus para a direita. O `turnright` pode ser abreviado para `tr`.

#### direction (dir)

direction

-     direction X

  O `direction` configura a direcção da tartaruga para um ângulo de X graus a contar do zero, e isto não é relativo à direcção anterior da tartaruga. O `direction` pode ser abreviado para `dir`.

#### center

center

-     center

  O `center` move a tartaruga para o centro da área de desenho.

#### go

go

-     go X,Y

  O `go` manda a tartaruga ir para um dado local da área de desenho. Este local está a X pixels do lado esquerdo da área de desenho e a Y pixels do topo da área. Lembre-se que, ao usar o comando `go`, a tartaruga não irá desenhar nenhuma linha.

#### gox

gox

-     gox X

  Ao usar o comando `gox`, a tartaruga irá mover-se X pixels a partir da esquerda da área de desenho, mantendo à mesma a sua altura.

#### goy

goy

-     goy Y

  Ao usar o comando `goy`, a tartaruga irá mover-se Y pixels a partir do topo da área de desenho, mantendo à mesma a sua distância ao lado esquerdo da área de desenho.

### A tartaruga tem um traço

A tartaruga tem um traço e vai desenhando uma linha à medida que a tartaruga se move. Existem alguns comandos para controlar o traço. Nesta secção iremos explicar estes comandos.

#### penup (pu)

penup

-     penup

  O `penup` levanta o traço da área de desenho. Quando o traço está em cima, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o `pendown`. O `penup` pode ser abreviado para `pu`.

#### pendown (pd)

pendown

-     pendown

  O `pendown` carrega no traço para baixo na área de desenho. Quando o traço está em baixo, é desenhada uma linha à medida que a tartaruga se move. Veja também o `penup`. O `pendown` pode ser abreviado para `pd`.

#### penwidth (pw)

penwidth

-     penwidth X

  O `penwidth` configura a espessura do traço para X pixels. O `penwidth` pode ser abreviado para `pw`.

#### pencolor (pc)

pencolor

-     pencolor R,G,B

  O `pencolor` configura a cor do traço. O `pencolor` recebe uma combinação de RGB como parâmetro. O `pencolor` pode ser abreviado para `pc`.

### Comandos para controlar a área de desenho

Existem vários comandos para controlar a área de desenho.

#### canvassize (cs)

canvassize

-     canvassize X,Y

  Com o comando `canvassize` você poderá alterar o tamanho da área de desenho. Ele recebe dois parâmetros X e Y à entrada, em que o X é a nova largura da área de desenho em pixels, e o Y é a nova altura da mesma área em pixels. O `canvassize` pode ser abreviado para `cs`.

#### canvascolor (cc)

canvascolor

-     canvascolor R,G,B

  O `canvascolor` define a cor da área de desenho. O `canvascolor` recebe uma combinação RGB como parâmetro. O `canvascolor` pode ser abreviado para `cc`.

#### wrapon

wrapon

-     wrapon

  Com o comando `wrapon` você poderá activar a envolvência para a área de desenho. Por favor veja o glossário para saber o que é a envolvência.

#### wrapoff

wrapoff

-     wrapoff

  Com o comando `wrapoff` você poderá desactivar a envolvência para a área de desenho. Isto significa que a tartaruga poder-se-á mover para fora da área de desenho e perder-se. Por favor veja o glossário se quiser saber o que é a envolvência.

### Comandos para limpar

Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo confuso.

#### clear (cr)

clear

-     clear

  Com o `clear`, você poderá limpar todos os desenhos da área respectiva. Tudo o resto permanece igual: a posição e o ângulo da tartaruga, a cor da área de trabalho, a visibilidade da tartaruga e o tamanho da área de desenho. O `clear` pode ser abreviado para `cr`.

#### reset

reset

-     reset

  O `reset` limpa tudo de forma mais abrangente que o comando `clear`. Depois de um comando `reset`, tudo fica tal e qual estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do ecrã, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho.

### A tartaruga é uma imagem móvel

Muitas das pessoas não sabem o que são as imagens móveis ('sprites'), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer o ecrã (para mais informações, veja o glossário sobre as imagens móveis).

A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.

[A versão actual do &kturtle; não suporta ainda o uso de imagens móveis que não apenas a tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa ao seu gosto]

#### show

show (ss)

-     show

  O `show` torna a tartaruga visível de novo depois de ter ficado escondida. O `show` pode ser abreviado para `ss`.

#### hide (sh)

hide

-     hide

  O `hide` esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O `hide` pode ser abreviado para `sh`.

### Será que as tartarugas escrevem texto?

A resposta é: sim. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.

#### print

print

-     print X

  O comando `print` é usado para dizer à tartaruga para escrever algo na área de desenho. O `print` recebe números e texto como parâmetros. Você poderá executar o `print` para vários parâmetros com o sinal +. Veja aqui um pequeno exemplo:

      ano = 2004
      autor = "Ze"
      print "O " + autor + " iniciou o projecto do KTurtle em " + ano + " e ainda continua a gostar de trabalhar nele!"

#### fontsize

fontsize

-     fontsize X

  O `fontsize` configura o tamanho da letra que é usado pelo `print`. O `fontsize` recebe um parâmetros que deverá ser um número. O tamanho é definido em pixels.

### Um comando que joga aos dados por si

Existe um comando que lança os dados para si, que se chama `random` e é muito útil para alguns resultados inesperados.

random

-     random X,Y

  O `random` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, em que o primeiro define o resultado mínimo (X) e o segundo o máximo (Y). O resultado é um número escolhido aleatoriamente que é maior ou igual ao mínimo e menor ou igual ao máximo. Aqui está um pequeno exemplo:

            repeat 500 [
              x = random 1,20
              forward x
              turnleft 10 - x
            ]

  Com o comando 'random', você poderá adicionar um pouco de confusão ao seu programa.

### Entrada de dados e reacção através de janelas

Uma janela poderá pedir alguma alguma reacção em especial ou a introdução de determinados dados. O &kturtle; tem dois comandos para janelas, nomeadamente o `message` e o `inputwindow`

#### message

message

-     message X

  O comando `message` recebe uma cadeia de caracteres à entrada. Mostra então uma janela que contém o texto da cadeia de caracteres.

      ano = 2004
      autor = "Ze"
      print "O " + autor + " iniciou o projecto do KTurtle em " + ano + " e ainda continua a gostar de trabalhar nele!"

#### inputwindow

inputwindow

-     inputwindow X

  O `inputwindow` recebe uma cadeia de caracteres à entrada. Mostra uma janela que contém o texto da cadeia de caracteres, tal como acontece no message. Contudo, para além disso, também mostra um campo de texto na janela. Através deste campo, o utilizador poderá introduzir um número ou uma cadeia de caracteres que poderá ser guardada num contentor. Por exemplo

      in = inputwindow "Que idade tem?"
      out = 2003 - in
      print "Em 2003, você tinha " + out + " anos a dada altura."

  Quando um utilizador cancelar a janela ou não introduzir nada de todo, o contentor fica vazio.

## Contentores

Os contentores são letras ou palavras que podem ser usadas pelo programador para guardar algum número ou algum texto. Os contentores que contêm um número chamam-se variáveis, enquanto que os que contêm texto chamam-se cadeias de caracteres.

Os contentores que não são usados não contêm nada. Por exemplo, um:

    print N

Isto não irá imprimir nada. Se tentar fazer operações matemáticas com contentores vazios, irá obter erros.

### Variáveis: contentores de números

Vamos começar com um exemplo:

    x = 3
    print x

Na primeira linha, a letra `x` passou a ser uma variável (um contentor de números). Como poderá ver, o valor da variável `x` passou a 3. Na segunda linha, o valor é impresso.

Lembre-se que, se quisesse imprimir um x, então deveria ser escrito

    print "x"

Isso foi fácil, mas agora há um exemplo um pouco mais difícil:

    A = 2004
    B = 25
    C = A + B

    # o próximo comando imprime "2029"
    print C
    backward 30
    # o próximo comando imprime "2004 mais 25"
    print A + " mais " + B
    backward 30
    # o próximo comando imprime "1979"
    print A - B

Nas duas primeiras linhas, as variáveis `A` e `B` são configuradas como sendo iguais a 2004 e 25. Na terceira linha, a variável `C` fica igual a `A + B`, o que dá 2029. O resto do exemplo consiste em 3 comandos `print` com `backward 30` no meio. O `backward 30` está lá para garantir que cada resultado fica numa linha diferente. Neste exemplo, você vê também que as variáveis podem ser usadas nos cálculos matemáticos.

### Contentores de texto (cadeias de caracteres)

No código do programa, o texto normal é iniciado e termina normalmente com aspas. Como já foi visto:

    print "Olá programador!"

O texto fica delimitado com as aspas. Estes pedaços de texto normal são chamados então de cadeias de caracteres.

As cadeias de caracteres são bastante parecidas com as variáveis. A maior diferença é que as cadeias de caracteres não podem ser usadas em cálculos matemáticos e perguntas. Um exemplo da utilização das cadeias de caracteres:

    x = "Olá "
    nome = inputwindow "por favor indique o seu nome..."
    print x + nome + ", como é que está?

Na segunda linha, a cadeia de caracteres `x` fica igual a Olá . Na segunda linha, a cadeia de caracteres `nome` é configurada como o resultado do comando `inputwindow`. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.

Este programa pede-lhe para introduzir o seu nome. Quando você, por exemplo, introduzir o nome Zé, o programa irá imprimir Olá Zé, como é que está?. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.

## Será que a Tartaruga Pode Fazer Contas?

Sim, o &kturtle; sabe fazer contas para si. Você poderá somar (+), subtrair (-), multiplicar (*) e dividir (/). Aqui está um exemplo no qual iremos usar todas as operações:

    a = 20 - 5
    b = 15 * 2
    c = 30 / 30
    d = 1 + 1
    print "a: "+a+", b: "+b+", c: "+c+", d: "+d

Será que sabe o valor de 'a', 'b', 'c' e 'd'? Repare por favor no uso do símbolo `=` de atribuição.

Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto:

    print 2004-12

Agora, um exemplo com parêntesis:

    print ( ( 20 - 5 ) * 2 / 30 ) + 1

O que estiver entre parêntesis será calculado em primeiro lugar. Neste exemplo, o 20-5 será calculado, depois será multiplicado por 2, dividido por 30 e depois é adicionado 1 (o que dá 2).

## Fazer perguntas, obter respostas...

O `if` e o `while` são controladores de execução que iremos discutir na próxima secção. Nesta secção iremos usar o comando `if` para explicar as perguntas.

### Perguntas

Um exemplo simples de perguntas:

    x = 6
    if x > 5 [
      print "olá"
    ]

Neste exemplo, a pergunta é `x > 5`, se a resposta a esta pergunta for true (verdadeira), o código entre parêntesis rectos será executado. As perguntas são uma parte importante da programação e são usadas normalmente em conjunto com os controladores de execução, como o `if`. Todos os números e variáveis (contentores de números) poderão ser comparados uns com os outros nas perguntas.

Aqui estão todas as perguntas possíveis:

### Tipos de perguntas

`a == b` | igual a | a resposta é true (verdadeira) se o `a` for igual ao `b`
`a != b` | é diferente de | a resposta é true (verdadeira) se o `a` não for igual ao `b`
`a > b` | maior que | a resposta é true (verdadeira) se o `a` for maior que o `b`
`a < b` | menor que | a resposta é true (verdadeira) se o `a` for menor que o `b`
`a >= b` | maior ou igual a | a resposta é true (verdadeira) se o `a` for maior ou igual ao `b`
`a <= b` | menor ou igual a | a resposta é true (verdadeira) se o `a` for menor ou igual ao `b`

As perguntas ficam realçadas com azul claro no editor de código.

### Colagem de Perguntas

As perguntas também podem ser coladas umas às outras com palavras de colagem de perguntas onde, desta forma, algumas perguntas tornam-se uma pergunta maior.

    a = 1
    b = 5
    if (a < 5) and (b == 5) [
      print "olá"
    ]

Neste exemplo, a palavra de colagem `and` é usada para colar 2 perguntas (`a < 5`, `b == 5`) em conjunto. Se um lado do `and` der uma resposta false (falsa), a pergunta toda irá responder false, porque, com a palavra de colagem `and`, ambos os lados precisam de ser true para que a resposta seja true (verdadeira). Por favor não se esqueça de usar os parêntesis à volta das perguntas!

Segue-se uma vista esquemática; pode encontrar uma explicação mais detalhada de seguida:

### Palavras de colagem de perguntas

`and` | ambos os lados têm de ser true (verdadeiros) para a resposta ser true (verdadeira)
`or` | se um dos lados for true (verdadeiros) a resposta é true (verdadeira)
`not` | Caso especial: só funciona com uma pergunta! Muda o 'true' para 'false' e o 'false' para 'true'.

As palavras de colagem ficam realçadas a púrpura no editor de código.

#### and

Quando são coladas duas perguntas em conjunto com o `and`, ambos os lados do `and` terão ser 'true' para que o resultado também seja 'true' (verdadeiro). Por exemplo:

    a = 1
    b = 5
    if ((a < 10) and (b == 5)) and (a < b) [
      print "olá"
    ]

Nestes exemplo, poderá ver uma pergunta colada a outra pergunta também colada.

#### or

Se uma das duas perguntas coladas em conjunto com o `or` for 'true' (verdadeira), o resultado será também 'true'. Por exemplo:

    a = 1
    b = 5
    if ((a < 10) or (b == 10)) or (a == 0) [
      print "olá"
    ]

Neste exemplo, irá ver uma pergunta colada a outra pergunta, também esta colada.

#### not

O `not` é uma palavra de colagem de perguntas especial que só funciona para uma pergunta de cada vez. O `not` muda o 'true' para 'false' e o 'false' para 'true'. Por exemplo:

    a = 1
    b = 5
    if not ((a < 10) and (b == 5)) [
      print "olá"
    ]
    else
    [
      print "não olá ;-)"
    ]

Neste exemplo, a pergunta colada é igual a 'true', embora o `not` a mude para 'false'. Como tal, no fim, será impresso o `"não olá ;-)"` na área de desenho.

## Controlar a execução

Os controladores de execução permitem-lhe — como o nome deles indica — controlar a execução.

Os comandos de controlo da execução ficam realçados a verde escuro e a negrito. Os parêntesis rectos, que são mais usados em conjunto com os controladores de execução, ficam realçados a verde claro.

### Fazer a tartaruga esperar

Se já tentou programar um pouco no &kturtle;, você já poderá ter reparado que a tartaruga pode ser bastante rápida a desenhar. Este comando faz a tartaruga andar um pouco mais devagar.

wait

-     wait X

  O `wait` faz a tartaruga esperar X segundos.

      repeat 36 [
        forward 5
        turnright 10
        wait 0.5
      ]

  Este código irá desenhar uma circunferência, mas a tartaruga irá esperar meio segundo a cada passo. Isto dá a noção de uma tartaruga vagarosa.

### Executar o "if"

if

-     if pergunta [ ... ]

  O código que é colocado no ... só será executado se (`if`) a resposta à pergunta for true (verdadeira). Por favor leia, para obter mais informações sobre perguntas, a secção de perguntas.

      x = 6
      if x > 5 [
        print "O x é maior que cinco!"
      ]

  Na primeira linha, o `x` é inicializado a 6. Na segunda linha, a pergunta `x > 5` é feita. Dado que a resposta a esta pergunta é verdadeira, o controlador de execução `if` irá permitir que o código entre parêntesis rectos seja executado

### O ciclo "while"

while

-     while pergunta [ ... ]

  O controlador de execução `while` é um pouco como o `if`. A diferença é que o `while` continua a repetir o código entre parêntesis até que a resposta à pergunta seja false (falsa).

      x = 1
      while x < 5 [
        forward 10
        wait 1
        x = x + 1
      ]

  Na primeira linha, o `x` fica igual a 1. Na segunda, a pergunta `x < 5` é feita. Dado que a resposta a esta pergunta é true (verdadeira), o controlador de execução `while` começa a execução do código entre parêntesis até que a resposta à pergunta seja false (falsa). Neste caso, o código entre parêntesis será executado 4 vezes, dado que, de cada vez que a quinta linha é executada, o `x` fica um número acima.

### Se não, por outras palavras: "else"

else

-     if pergunta [ ... ] else [ ... ]

  O `else` pode ser usado para além do controlador de execução `if`. O código entre parêntesis a seguir ao `else` só é executado se a resposta à pergunta que é feita for false (falsa).

      x = 4
      if x > 5 [
        print "O x é maior que cinco!"
      ] else [
        print "O x é menor que seis!"
      ]

  A pergunta testa se o `x` é maior que 5. Dado que o `x` fica igual a 4 na primeira linha, a resposta à pergunta é false (falsa). Isto significa que o código entre parêntesis a seguir ao `else` é executado.

### O ciclo "for", um ciclo de contagem

for

-     for ponto inicial a ponto final [ ... ]

  O ciclo `for` é um ciclo de contagem, ou seja, faz de contador para si.

      for x = 1 to 10 [
        print x * 7
        forward 15
      ]

  De cada vez que o código entre parêntesis é executado, o `x` é incrementado de uma unidade, até que o valor do `x` chegue a 10. O código entre parêntesis imprime o valor de `x` multiplicado por 7. Depois de este programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.

## Crie os seus próprios comandos com o learn

O `learn` é um comando muito especial, porque é usado para criar os seus próprios comandos. O comando que criar poderá receber parâmetros e devolver resultados. Vamos ver como é que é criado um novo comando.

    learn circunferencia x [
      repeat 36 [
        forward x
        turnleft 10
      ]
    ]

O novo comando chama-se `circunferencia`. O `circunferencia` recebe um parâmetro, um número, para definir o tamanho da circunferência. O `circunferencia` não devolve nenhum resultado. O comando `circunferencia` pode agora ser usado como um comando normal. Veja este exemplo:

    learn circunferencia X [
      repeat 36 [
        forward X
        turnleft 10
      ]
    ]

    go 30,30
    circunferencia 20

    go 40,40
    circunferencia 50

No próximo exemplo, vai ser criado um comando com um valor de resultado devolvido.

    learn multiplicarPeloProprio n [
      r = n * 1
      r = n * n
      return r
    ]
    i = inputwindow "Por favor indique um número e carregue em OK"
    print "O " + i + " multiplicado por ele próprio é igual a: " + multiplicarPeloProprio i

Neste exemplo, existe agora um comando novo chamado `multiplicarPeloProprio`. O parâmetro deste comando é multiplicado por ele próprio e é então devolvido, usando o comando `return`. O comando `return` é a forma de devolver um resultado de uma função criada.