DEV Community: Cumbuca Dev

Executando uma Linguagem Interpretada - Pituguês

Cumbuca Dev — Wed, 29 Apr 2026 19:32:42 +0000

Agora que já geramos a AST do Pituguês através do Avaliador Sintático, chegou o momento de entendermos o processo por que nosso código passa para ser executado. Por estarmos tratando de uma linguagem interpretada, nossas instruções estarão sendo traduzidas para código de máquina de forma simultânea, como já comentamos neste artigo a respeito da diferença entre linguagens interpretadas e compiladas.

Impacto da Linguagem Interpretada

Quando falamos sobre a diferença entre a linguagem interpretada e a linguagem compilada, anteriormente, acabamos não deixando tão clara a aplicabilidade de cada uma delas.

Voltando um pouquinho no tempo, vamos pensar que, há alguns anos, era muito comum que fosse necessário instalar algum software na sua máquina para se ter acesso àquela funcionalidade/recurso. Antigamente, para conseguirmos nos comunicar por mensagens instantâneas em chats individuais, era comum instalarmos um software como o MSN Messenger, por exemplo, no computador.

Para um software assim rodar no seu computador, ele precisava ser construído para aquele sistema operacional e aquela máquina em específico, o que requer um desenvolvimento em uma linguagem compilada. Afinal, são estes tipos de linguagens em que, após sofrer o processo de build, conseguem traduzir um código de alto nível para a linguagem de máquina e que correspondem às exigências que aquele dispositivo requer. O que significaria que não haveria portabilidade entre dispositivos, uma vez que aquele programa foi desenvolvido para aquela máquina.

Além disso, depois que um código é compilado, aquele programa fica ali fechadinho em si e não conseguimos simplesmente fazer manutenção naquele código, mas precisamos retomar o código do programa e passar pelo processo de gerar um novo programa com as correções e deletar o antigo.
Com o desenvolvimento e ampla aderência dos navegadores (browsers), começou a se dispensar a exigência de se ter um software instalado no seu computador para que você pudesse ter acesso àquele serviço. Tornou-se possível termos aplicações de troca de mensagens instantâneas como a versão web para o What'sApp em que podemos fazer o nosso login e ainda ter acesso às nossas conversas e lista de contatos sempre precisar da instalação de uma aplicação para aquela finalidade.

O impacto que os navegadores trouxeram foi justamente este de "encurtar o caminho" de execução das funcionalidades de um serviço, uma vez que eles têm a capacidade de interpretar instruções escritas em linguagens de programação interpretadas que são executadas sem passarem pela compilação, mas em tempo real. O que desobriga a instalação de aplicativos especializados para diferentes tipos de serviços.

Isto significa que poderemos criar uma série de sistemas que ficarão hospedados na web e, quando algum usuário quiser acessar aquele serviço específico, ele apenas precisará navegar até o endereço em que este serviço está disponível e o browser é que será responsável por fornecer o acesso do usuário àquele serviço. E como são aplicações que não passam pela compilação, são mais maleáveis em sua manutenibilidade.

Ou seja, no ambiente web, as linguagens interpretadas possuem um poderio imensurável!

E justamente por terem esta característica que elas acabam se tornando agentes facilitadoras na portabilidade e flexibilidade de se construir e ofertar diversos tipos de serviços.

Uma linguagem interpretada em português

A área de desenvolvimento de software vem ganhando destaque nos últimos anos, principalmente após a pandemia do COVID-19 em que muitas atividades precisaram se incluir no meio digital e o mercado de TI se viu precisando de mais profissionais. Diante deste cenário, uma expressiva parcela de falantes da língua portuguesa vem buscando formação neste universo devido ao mercado aquecido.

No entanto, a gente já comentou nesta outra postagem sobre como as linguagens de programação que são usadas comercialmente podem ser desafiadoras para falantes lusófonos, especialmente para pessoas iniciantes em programação e por isso linguagens em português podem ser uma excelente porta de entrada para estas pessoas.

Por mais que existam outras linguagens de programação em português, elas ainda são voltadas apenas a fins didáticos e seu uso ocorre em "ambientes controlados", em editores de código exclusivos, ou até mesmo conseguem rodar no ambiente da web. E, embora contribuam imensamente como ferramenta de ensino de algoritmos e lógica de programação, não conseguimos criar e disseminar soluções em função desta limitação de não serem suportadas pelos interpretadores dos browsers.

E é verdade que a revolução conquistada pelos browsers em dispensar a necessidade de uma aplicação específica para diferentes sistemas torna o desenvolvimento de aplicações mais flexível e até mesmo mais ágil. Mas eles ainda utilizam linguagens de programação em língua inglesa e precisamos lembrar das dificuldades enfrentadas por falantes da língua portuguesa ao aprender a programação.

Com a ampla difusão dos navegadores e, como vimos antes, sua capacidade de executar serviços desenvolvidos com linguagens interpretadas, acreditamos que há espaço para se desenvolver uma linguagem interpretada em português que vá além da proposta educacional!

Ao construirmos uma linguagem interpretada em português que consegue ser interpretada pelo Google Chrome, Opera, Firefox,Edge e entre outros, possibilitamos que falantes de língua portuguesa consigam usar essa mesma linguagem para criar!

Com isto, temos a oportunidade de desenvolver e produzir serviços web em português! O que poderá contribuir para a geração de renda no mercado nacional!

Então, por que não construir uma linguagem de programação interpretada em português que seja suportada pelos navegadores para desenvolvimento de serviços web e que contribua na geração de trabalho e renda, uma vez que teríamos a barreira linguística superada?

É isto que se busca oportunizar com o Pituguês: uma linguagem interpretada que possa ser executada em qualquer dispositivo que tenha acesso a um navegador!

O Interpretador

Agora, chegou o momento de entendermos como funciona o código do Interpretador!

Depois de passarmos pelo processo do Avaliador Sintático, onde é verificado se a nossa instrução em Pituguês está de acordo com a sintaxe esperada e também acontece a construção da AST (Abstract Syntax Tree, ou Árvore Sintática Abstrata) do programa, ainda nos resta desenvolver a etapa que irá, de fato, executar o nosso comando.

Vamos retomar o exemplo de código que trabalhamos no Avaliador Sintático:

letra = "b"
se letra == "a":
    escreva("Letra A")
senao:
    escreva("Não é letra A")

O Avaliador Sintático acabou gerando uma lista de declarações, que vem a ser a nossa AST, o que podemos chamar de "ramos da árvore", em que temos uma visão panorâmica quanto aos componentes que existem no nosso programa:

declaracoes: [
    Var {
      linha: 1,
      hashArquivo: undefined,
      decoradores: [],
      assinaturaMetodo: '<principal>',
      simbolo: [Simbolo],
      inicializador: [Literal],
      tipo: 'texto',
      tipoExplicito: false,
      referencia: false,
      desestruturacao: false
    },
    Se {
      linha: 2,
      hashArquivo: 0,
      decoradores: [],
      assinaturaMetodo: '<principal>',
      condicao: [Binario],
      caminhoEntao: [Bloco],
      caminhosSeSenao: [],
      caminhoSenao: [Bloco]
    }
  ]

Aqui temos a ideia geral das declarações existentes no programa, mas não conseguimos ter acesso ao código em si e, como comentamos no artigo sobre o Avaliador Sintático, agora é responsabilidade do Interpretador percorrer esta lista de declarações, adentrar em cada uma delas e fazer com que o código seja executado.

Executando a AST

Agora que geramos e temos acesso à AST do nosso código, o Interpretador precisa conseguir acessar cada ramificação do nosso código para executar as instruções ali escritas. Como abordamos no artigo anterior, estruturas de dados em árvores não podem ser acessadas da mesma forma que estruturas lineares, uma vez que elas possuem toda uma hierarquia e conexões entre seus nós.

Para este tipo de estrutura a literatura indica a utilização de um Design Pattern conhecido por Visitor Pattern - ou "Padrão Visitante" em tradução livre. Este padrão de projeto foi descrito no livro de mesmo nome, "Design Patterns", que apresenta uma série de problemas estruturais que podem ser enfrentados no código de um projeto e traz soluções através destes padrões de projeto.

Uma linguagem de programação deve conseguir implementar diversos comportamentos e ainda ser possível expandi-los, mas isto precisa ser feito de uma forma que não cause interferência em elementos que já existem e que ainda se consiga fazer a manutenção da linguagem quando necessário. Nesse sentido, o Visitor Pattern consegue cumprir estes requisitos por usar e abusar dos pilares de polimorfismo e herança que a Programação Orientada a Objetos oferece.

Para conhecer um pouco mais sobre este padrão de projeto, recomendamos a leitura do artigo sobre Visitor Patterns do Refactoring Guru e deste artigo no Medium sobre aplicar o Visitor Pattern em um interpretador de linguagem.

Visitor Pattern - ou Padrão Visitante

Nesta seção, iremos abordar o Padrão Visitante já aplicado no Pituguês, portanto, se seu entendimento ficar um pouco confuso, recomendamos a leitura prévia dos artigos referidos na seção anterior.

Para desenvolvermos a nossa solução com este padrão de projeto, precisamos ter definido três componentes-chave:

1. Visitor Interface (Interface dos Visitantes)

Como toda interface, aqui, vamos apenas definir os métodos abstratos das operações que queremos efetuar e você pode encontrar este componente de Pituguês neste arquivo da interface VisitanteComumInterface. Ou seja, as funções apenas possuem métodos abstratos declarados e seus nomes e argumentos são descritos para que seja seguido um padrão de aplicação destes comportamentos que serão desenvolvidos em outras classes.

Note que há declarados os métodos referentes a visitarDeclaracaoVariavel, visitarDeclaracaoSe e visitarDeclaracaoEscreva, que são referentes ao comportamento das declarações que o Avaliador Sintático identificou no nosso código de exemplo.

2. Concrete Visitors (Visitantes Concretos)

São as classes que vão implementar estes métodos declarados na interface VisitanteComumInterface e que vão ser desenvolvidas em classes como a InterpretadorBase, disponível neste arquivo.

É importante estar atento em como usamos a herança para implementar as funcionalidades que queremos no projeto do Pituguês. Para chegarmos na classe em que estão desenvolvidas estas "funções visitantes", vamos passar pelo caminho:

VisitanteComumInterface: declaração de métodos abstratos de visitação.
InterpretadorInterface: herda o VisitanteComumInterface com seus métodos abstratos, além de declarar os atributos e novos métodos que irão cumprir o papel de executar as instruções que escreveremos em Pituguês.
InterpretadorBase: implementa o InterpretadorInterface que traz consigo tanto seus métodos abstratos como os de VisitanteComumInterface que, agora, já possui implementação, já tem seus comportamentos desenvolvidos.
Interpretador: irá herdar o InterpretadorBase com as funções já desenvolvidas, assim como irá sobrescrever algumas delas.
InterpretadorPitugues: herda o Interpretador com seus métodos e também sobrescreve alguns deles.

Em suma, para desenvolvimento do Interpretador do Pituguês, este fluxo de heranças se faz necessário para que possamos usufruir ao máximo do reaproveitamento de código, uma vez que estas classes podem ser reutilizadas em outros dialetos que Delégua suporta, o que acabou resultando no caminho:

VisitanteComumInterface > InterpretadorInterface > InterpretadorBase > Interpretador > InterpretadorPitugues

E é dentro do código em InterpretadorBase que vamos ter desenvolvidos os comportamentos de:

visitarDeclaracaoVariavel
visitarDeclaracaoSe
visitarDeclaracaoEscreva

3. Visitable Elements (Elementos Visitáveis)

Aqui vamos começar a ter os objetos correspondentes às funcionalidades e recursos que queremos incluir na nossa linguagem e, novamente, vamos usar o pilar para herança para que possamos adicionar elementos sem interferir uns nos outros.

Primeiramente, devemos lembrar que o Interpretador recebe uma AST de declarações do nosso código, então, vamos ter uma classe abstrata chamada Declaracao que vai conter atributos que mapeiam a declaração específica e a função aceitar que será da seguinte forma:

async aceitar(visitante: VisitanteComumInterface): Promise<any> {
    return Promise.reject(new Error('Este método não deveria ser chamado.'));
}

Repare que a função recebe como argumento um objeto chamado visitante do mesmo tipo da nossa primeira interface que declara os métodos de visitação: VisitanteComumInterface.

Agora, precisamos implementar a nossa classe abstrata e esta função em uma "classe concreta", uma classe que poderá inicializar um objeto e vamos tomar como exemplo o comportamento de criação de variável. Ou seja, teremos uma classe para declaração de variável chamada Var que irá sobrescrever a função aceitar, declarada na classe Declaracao, implementando o comportamento necessário para sua execução, o que irá resultar em:

async aceitar(visitante: VisitanteComumInterface): Promise<any> {
    return await visitante.visitarDeclaracaoVar(this);
}

Nesta sobrescrita, estamos nos referindo a uma função cujo desenvolvimento se encontra em IntrepretadorBase e que, logo em seguida, iremos apresentar qual é o percurso que é feito para chegar até aqui e executar a instrução pelo Interpretador.

Visitando as Declarações

ATENÇÃO: Recomendamos que você acompanhe o código do Interpretador durante a leitura! Disponibilizaremos os links para o código referido ao longo do texto.

Como já vimos antes, a AST é constituída pelas declarações geradas pelo Avaliador Sintático e precisamos usar o Padrão Visitante para percorrer esta árvore, adentrar seus ramos e executar o trecho de código que existe dentro de cada um deles.
Vamos iniciar nosso passeio no arquivo de testes...

1. Testes do Interpretador do Pituguês

NOTA: Você pode acessar o arquivo por este link.

Vamos adicionar um teste unitário com o nosso código de exemplo para simular qual seria o trajeto que o interpretador faria para executá-lo caso estivéssemos usando uma IDE. Então, temos o teste:

it('Teste do exemplo de código presente no artigo sobre o Interpretador', async () => {
    const retornoLexador = lexador.mapear([
        'letra = "b"',
        'se letra == "a":',
        '    escreva("Letra A")',
        'senao:',
        '    escreva("Não é letra A")'
    ], -1);

    const retornoAvaliadorSintatico = await avaliadorSintatico.analisar(
        retornoLexador,
        -1
    );

    const retornoInterpretador = await interpretador.interpretar(
        retornoAvaliadorSintatico.declaracoes
    );

     expect(retornoInterpretador.erros).toHaveLength(0);
});

Neste teste, temos que repassar sequencialmente os retornos do Lexador para o Avaliador Sintático e do Avaliador Sintático para o Interpretador. O Interpretador irá chamar a função interpretar, que recebe as nossas declarações já identificadas pelo Avaliador Sintático e, agora, vamos conseguir entender um pouco mais o percurso que o Padrão Visitante faz ao entrar dentro da função interpretar.

2. Função `interpretar` da classe `Interpretador`

Inicialmente, vamos parar dentro do arquivo da classe Interpretador, cuja função interpretar consta como sobrescrita, ou seja, ela é herdada de outra classe, e logo em seguida temos o trecho de código:

const resultados = await super.interpretar(declaracoes, manterAmbiente);

Esta linha de código visa obter os resultados das declarações recebidas como argumentos a serem executadas, mas ela redireciona para outra função interpretar que pertence à classe mãe.

3. Função `interpretar` da classe `InterpretadorBase`

O InterpretadorBase está disponível neste arquivo.

Aqui, nós vamos inicializar atributos referentes aos erros, escopo e pilha de execução e, mais abaixo, o código irá buscar se conseguirá receber um retorno das declarações ou algum erro e isto está declarado na linha:

const retornoOuErro = await this.executarUltimoEscopo(manterAmbiente);

4. Função `executarUltimoEscopo` da classe `Interpretador`

Voltamos à classe [Interpretador](https://github.com/DesignLiquido/delegua/blob/principal/fontes/interpretador/interpretador.ts), em que será capturada a declaracaoAtual que está em espera na pilha de execução para ser executada até chegamos à instrução:

retornoExecucao = await this.executar(declaracaoAtual);

5. Função `executar` da classe `InterpretadorBase`

Todo esse caminho percorrido, até então, ilustra como o Interpretador recebe a AST do código de exemplo e tira proveito do Padrão Visitante para reaproveitamento e padronização do código, mas ele ainda não foi executado, apenas estamos identificando de qual declaração se trata para que ela possa ser executada.

De toda forma, agora é o momento em que vamos começar a direcionar a nossa declaração para o objeto dela e começar a ver o Padrão Visitante em ação e como o Interpretador descobre qual instrução ele precisará executar.

6. Função `aceitar` nas classes `Var` e `Se`

Lembrando que a função aceitar foi declarada em uma classe abstrata Declaracao para ser herdada por outras declarações. Ela recebe como argumento um objeto do tipo VisitanteComumInterface que é uma interface cujos métodos estão implementados e desenvolvidos no InterpretadorBase.

Na etapa 5, a função aceitar recebeu tanto a declaração Var como a Se e o código de cada uma delas se encontra desenvolvido desta forma:

Declaração Var

Primeiramente, o Interpretador irá reconhecer a primeira linha do nosso código:

letra = "b"

É uma instrução que já foi identificada pelo Avaliador Sintática como uma declaração Var e, dentro do seu código, ela herda a classe Declaracao, como já foi comentado, e aplica a função aceitar. Porém, quando estamos dentro da classe da declaração Var, aceitar é sobrescrita:

async aceitar(visitante: VisitanteComumInterface): Promise<any> {
    return await visitante.visitarDeclaracaoVar(this);
}

Declaração Se

Em sequência, o Interpretador irá avançar para a próxima declaração, cujo código é:

se letra == "a":
    escreva("Letra A")
senao:
    escreva("Não é letra A")

A declaração Se também irá herdar e aplicar a função aceitar da seguinte forma:

async aceitar(visitante: VisitanteComumInterface): Promise<any> {
    return await visitante.visitarDeclaracaoSe(this);
}

Repare que ambas recebem como argumento um visitante de tipo VisitanteComumInterface , interface em foram declaradas nela funções abstratas e foram desenvolvidas em InterpretadorBase.

A partir do momento que a função aceitar, na etapa 5, recebe uma declaração de um determinado tipo, é o que vai permitir que o InterpretadorBase seja direcionado para visitar o objeto da declaração, no nosso caso, as declarações Var e Se. E, sem sequência, Var e Se irão determinar qual método de visitação será chamado na o InterpretadorBase para que sejam executadas.

7. Funções `visitarDeclaracaoVar` e `visitarDeclaracaoSe`

Somos redirecionados, novamente, para o InterpretadorBase que é onde estão desenvolvidas as funções de visitação das declarações.

Para a declaração Var, vamos ter:

async visitarDeclaracaoVar(declaracao: Var): Promise<any> {
    const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
    let tipoResolvido = declaracao.tipo;
    if (tipoResolvido.startsWith('função<')) {
        tipoResolvido = tipoResolvido.replace('função<', '').replace('>', '');
    }

    this.pilhaEscoposExecucao.definirVariavel(
        declaracao.simbolo.lexema,
        valorFinal,
        tipoResolvido
    );

    return null;
}

Aqui, a nossa variável vai passar por uma verificação para garantir seu tipo e averiguar se já foi declarada antes ou não, até ser incluída na pilha de escopo para execução.

Para a declaração Se:

async visitarDeclaracaoSe(declaracao: Se): Promise<any> {
        const avaliacaoCondicaoSe = await this.avaliar(declaracao.condicao);
        if (this.eVerdadeiro(avaliacaoCondicaoSe)) {
            return await this.executar(declaracao.caminhoEntao);
        }

        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
            // TODO: Qual o tipo de `atual`?
            const atual = declaracao.caminhosSeSenao[i] as any;

            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
                return await this.executar(atual.caminho);
            }
        }

        if (declaracao.caminhoSenao !== null) {
            return await this.executar(declaracao.caminhoSenao);
        }

        return null;
    }

A condicional será avaliada aqui e o código irá mapear quais outras declarações e expressões existem dentro de Se. Isto fará com que o Interpretador percorra todo aquele caminho que foi criado com o Padrão Visitante para identificar e executar as declarações, blocos e expressões dentro do Se e que serão adicionadas à pilha de escopo para execução.

Contribua com o Pituguês!

Agora que você sabe o que é o Padrão Visitante e como ele funciona aplicado no Interpretador do Pituguês, você já está apto a contribuir com ele!

Como comentamos, o código-fonte do Pituguês mora dentro de Delégua, então você irá encontrá-lo neste repositório do GitHub.

Além disso, também preparamos este documento que te guia em como contribuir com a linguagem, em que damos uma visão geral da estrutura do código e os arquivos principais para você contribuir com o Pituguês.

Caso encontre alguma dificuldade, a Design Líquido fez um vídeo demonstrando como programar e contribuir com o Interpretador e você pode pegar inspirações de lá!

Mas com o que posso contribuir?

De diversas formas... você pode usar a linguagem e reportar bugs pra gente, pode divulgar a linguagem e até mesmo fazer contribuições diretas no código-fonte...

Dica

*Para contribuir com o Avaliador Sintático: investigue e analise os construtos que já existem na linguagem, pense o que mais você incluiria e/ou melhoria e vem contar pra gente!
*

Um pequeno adendo sobre contribuições...

Aderir a boas práticas, registrando no GitHub seu processo de contribuição, é de suma importância! No guia de contribuição que trouxemos para vocês, é ensinado como buscar por issues para contribuir - ou abrir as próprias issues - e como fazer um PR (Pull Request). Parte da função dessas etapas é deixar documentado e acessível para que outros contribuidores possam acompanhar o desenvolvimento do projeto.

Aliás, não apenas para que outras pessoas consigam acompanhar o desenrolar do projeto, mas também é uma forma de mostrar para o mundo o seu trabalho! Aqui, na Cumbuca Dev, a gente promove e incentiva a contribuição em projetos de Código Aberto, por ser uma das formas de pessoas iniciantes aprenderem e se desenvolverem na programação, enquanto conquistam experiência real que será super válida para o mercado de trabalho!

Ou seja, enquanto você consegue participar ativamente, ajudando com o crescimento de um projeto e trocando ideia com outros contribuidores, também consegue desenvolver suas habilidades! E como tudo isso é feito com transparência, você pode facilmente comprovar experiência! <3

E agora?

Bom, agora que você já sabe como funciona e como se programa um Interpretador, te convidamos a aprender e testar o Pituguês! 😉 Escrevemos este tutorial para te ensinar como programar com ele! Além disso, você sempre pode consultar a documentação!

Neste repositório temos descrito alguns desafios para fazer em Pituguês! E se, por caso, tiver qualquer dificuldade com a linguagem, já pode reportar pra gente que te ajudamos!

Avaliador Sintático: Como Funciona no Pituguês

Cumbuca Dev — Mon, 23 Mar 2026 12:51:12 +0000

Depois de tratarmos sobre o Lexador, vamos avançar para a próxima etapa do processo que torna possível transformar uma linguagem de alto nível em linguagem de máquina, permitindo o desenvolvimento de uma linguagem de programação: o Avaliador Sintático!

Este termo foi a escolha feita pela Design Líquido como tradução de um parser, mas também podemos encontrar por aí outros nomes equivalentes como AST Walker, AST Evaluator ou até mesmo Analisador Sintático.

Retomando alguns conceitos…

Lembram que o Lexador gera uma lista de símbolos (tokens) a partir das instruções que escrevemos no código-fonte do nosso programa? Tomemos o mesmo exemplo do artigo anterior, ao declararmos a variável:

nome_da_linguagem = "Pituguês"

O Lexador irá mapear cada elemento que contém nesta linha de código, retornando um vetor (array) de objetos Símbolo, em que é identificado o seu tipo e lexema. Estas informação são imprediscíveis para que o Avaliador Sintático possa dar continuidade da tradução da linguagem de alto nível para a de baixo nível e, assim, executar o programa que escrevemos.

Mas escrever código e ter seus símbolos identificados por um Lexador não é o suficiente para que se possa tornar uma linguagem de programação executável, é a apenas a primeira parte do processo. Tomando como exemplo o Pituguês, imagine que o Lexador foi capaz de identificar a declaração de variável da seguinte linha de código:

var nome_da_linguagem = "Pituguês"
Nessa linha de código, o Lexador identificou que há dois símbolos que foram categorizados como identificadores, como nomes de variáveis, a palavra var e a palavra nome_da_linguagem. Até aí tudo bem, porque é a função dele apenas mapear os símbolos e seu tipos.

Mas quando tentamos executar este código…

A palavra var não é reconhecida pela linguagem por não fazer para de sua gramática e por isto temos retornado o erro acima que nos impede de executar o código. Afinal, assim como um idioma que segue uma estrutura sintática para gerar conexão entre palavras e transmitirmos uma mensagem, as linguagens de programação funcionam da mesma forma.

Os símbolos que compõem uma instrução de um código precisam o corresponder a uma ordem para serem reconhecidos dentro da regra gramatical da linguagem. Então, por exemplo, não podemos declarar uma variável assim:

nome_da_linguagem "Pituguês" =

Como o Avaliador Sintático avalia os tokens do Lexador?

Como foi comentado antes, o Lexador gera uma lista dos símbolos que existem no código escrito e ele vai enviar essa lista para o Avaliador Sintático. A partir do momento em que o Avaliador Sintático tem acesso a esta lista de símbolos com seus devidos tipos identificados, ele terá ciência sobre o significado daquele símbolo. Isto é de suma importância pois é como o Avaliador conseguirá determinar a função daquela comando no programa.

Esta etapa é como se fosse uma análise sintática de uma oração mesmo, um momento em que iremos identificar a classe e função de cada palavra em uma frase, como:

Perceba que cada palavra está ordenada de uma forma que faça sentindo para transmitir sua mensagem na língua portuguesa. Cada palavra pertence a uma classificação gramatical que possui uma função específica que determina seu propósito dentro da frase.

Usando o exemplo da frase acima, é como se o Lexador identificasse que existe um pronome, um verbo, uma preposição e um substantivo, nessa respectiva ordem. O Avaliador Sintático vai, agora, identificar qual é a função desses elementos e verificar se eles estão ordenados seguindo o padrão de “SUJEITO + VERBO + OBJETO”.

A nossa linha de código vai sofrer um processo parecido de identificação quanto a função dela naquele programa. Mas, desta vez, irá analisar se há elementos como variáveis, condicionais, laços de repetição e etc. Tomemos como exemplo a declaração de variável que já usamos antes do Pituguês:

nome_da_linguagem = "Pituguês

Quando o Avaliador recebe esta linha de código, terá sido mapeado que ali temos um identificador, um sinal de atribuição de valor e, por último, temos o valor, um dado de tipo textual. Após receber esta sequência de caracteres com seus significado, será analisado se aquela linha de código está na ordem correta para que seja considerada uma declaração variável. Isto será processado dentro desta função (você pode encontrá-la aqui):

private async declaracaoImplicitaVariaveis(): Promise<Var> {
    const identificador = this.consumir(
        tiposDeSimbolos.IDENTIFICADOR,
        'Esperado nome de variável.'
    );
    this.consumir(tiposDeSimbolos.IGUAL, "Esperado '=' após identificador.");
    if (this.estaNoFinal()) {
        throw this.erro(
            this.simboloAnterior(),
            'Esperado valor após o símbolo de igual.'
        )
    }
    const valor = await this.expressao();
    const tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(valor, 'qualquer');
    this.pilhaEscopos.definirInformacoesVariavel(
        identificador.lexema,
        new InformacaoElementoSintatico(identificador.lexema, tipo)
    );
    return new Var(identificador, valor, tipo);
}

Nesta função, em código TypeScript, sua assinatura espera que seja construído um objeto do tipo Var, para criarmos uma variável, após o avaliador receber aquela linha de código. Só que esta variável só será construída após passar pelas validações na função acima:

const identificador: irá armazenar o identificador a nossa variável;
É validado se existe o sinal de igual para atribuição de valor;
Verifica se há algum valor após o sinal de atribuição;
const valor: é quando o código vai verificar qual é o dado que queremos armazenar na variável;
const tipo: a partir do valor, identifica o tipo do dado;
Adiciona à pilha de escopo do programa a variável;
Por fim, a função retorna um objeto Var, com as constantes e seus valores definidos na função: identificador, valore tipo.
Ou seja, apenas após passar por todo esse processamento e validações é que o Pituguês conseguiu gerar uma variável para aquela linha de código.

Composição de um programa

Até aqui, conseguimos entender como o Avaliador Sintático é capaz de reconhecer uma variável, só que é preciso lembrar que um programa não consiste em apenas um elemento. Geralmente, acabamos usando uma série de construções como condicionais, funções, laços de repetição, criação de classes, enfim, temos uma ampla gama de comandos que podemos elaborar num programa.

Todavia, além do processo de identificar as instruções do código, a função do Avaliador Sintático também é construir uma forma de representação hierárquica dele, conhecida por AST (Abstract Syntax Tree, ou Árvore de Sintaxe Abstrata). E é essa representação que, mais a frente, permitirá que nosso Interpretador percorra e execute o programa desenvolvido.

Mas, antes, vamos entender o que é uma…

Estrutura de Dados em Árvore

Quando nos referimos ao tema de estrutura de dados, lidamos com formas de armazenamento de dados que são lineares por terem um início e um fim, como vetores, pilhas e filas. A árvore também é uma estrutura de dados, porém, ela não opera de forma linear como as outras mencionadas, mas de maneira hierárquica e permite um crescimento contínuo de dados.

Imagine que você elaborou uma lista de filmes que quer baixar para assistir mais tarde. Pensando em estrutura de dados, você pode guardar essa lista num vetor, como, por exemplo:

lista_de_filmes = [
 "Um conto chinês",
 "Nunca deixe de lembrar",
 "Nosferatu",
 "O enigma de Kaspar Hauser".
 "Cidade de Deus",
 "Minha mãe é uma peça",
 "Bacurau",
 "Parasita",
 "Invasão Zumbi"
]

Em um vetor, conseguimos ter essa visão mais panorâmica do que há na nossa lista e selecionar um item pela sua posição dentro do vetor, simplesmente por percorrer a estrutura com um laço de repetição, por exemplo. E até aqui tudo bem, porque a intenção era apenas de ter uma listagem dos filmes que se pretendia assistir.

Agora, você já baixou os filmes e criou uma pasta chamada FILMES no seu computador para deixar eles guardadinhos ali dentro, mas isso te deixou incomodado porque só colocar os arquivos ali não ficou exatamente organizado. Então, que tal organizar os filmes de acordo com seu país de lançamento?

Podemos ter uma organização em que iremos aninhar os filmes de acordo com seu país e ela ficaria mais ou mesmo assim…

├── FILMES
│ ├── Argentina
│ │ ├── Um conto chinês
│ ├── Alemanha
│ │ ├── Nunca deixe de lembrar
│ │ ├── Nosferatu
│ │ ├── O enigma de Kaspar Hauser
│ ├── Brasil
│ │ ├── Cidade de Deus
│ │ ├── Minha mãe é uma peça
│ │ ├── Bacurau
│ ├── Coreia do Sul
│ │ ├── Parasita
│ │ ├── Invasão Zumbi

É só pensar num sistema de arquivos no seu computador de forma simplificada: depois de dividir os filmes em diretórios de acordo com seu país, você não vai mais conseguir acessar o filme da mesma forma que conseguia como no vetor de antes.

Agora, se quiser assistir o filme “Cidade de Deus”, vai precisar navegar pelo caminho de:

Selecionar o diretório FILMES
Depois o diretório Brasil
E, por fim, o filme “Cidade de Deus“

Ou seja, a partir do momento que eu quero ter acesso aos filmes que estão na pasta Brasil, eu já não tenho acesso visível aos filmes que estão aninhanados em outros países. Então, se eu estiver ainda dentro de Brasil, caso eu mude de ideia e queira assistir um filme da Argentina, eu vou precisar retroceder um diretório para poder entrar em outro, isto porque cada um do filmes está organizado na pasta do seu respectivo país.

É mais ou menos assim que uma estrutura de dados em árvore se comporta. Você só consegue ter acesso àquele dado/informação se estiver “dentro do guarda-chuva dele”. É justamente por isso que não haverá linearidade em uma árvore, pois os dados estarão organizados, de novo, hierarquicamente.

Se você quiser ler mais um pouquinho sobre as árvores, recomendamos este artigo.

A AST do Avaliador Sintático

Para que nosso programa em Pituguês seja executado o Avaliador Sintático não irá apenas identificar a função de cada trecho do código, mas vai gerar uma hierarquia em árvore dele. Vamos usar como exemplo o seguinte código:

letra = "b"
se letra == "a":
    escreva("Letra A")
senao:
    "escreva("Não é letra A")

Como comentamos, o Lexador irá mapear cada token presente em cada linha, retornando algo assim:

simbolos: [
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'letra',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IGUAL',
      lexema: '=',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'b',
      literal: 'b',
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'SE',
      lexema: 'se',
      literal: null,
      linha: 2,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'letra',
      literal: null,
      linha: 2,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IGUAL_IGUAL',
      lexema: '=',
      literal: null,
      linha: 2,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'a',
      literal: 'a',
      linha: 2,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'DOIS_PONTOS',
      lexema: '',
      literal: null,
      linha: 2,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'ESCREVA',
      lexema: 'escreva',
      literal: null,
      linha: 3,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'PARENTESE_ESQUERDO',
      lexema: '',
      literal: null,
      linha: 3,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'Letra A',
      literal: 'Letra A',
      linha: 3,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'PARENTESE_DIREITO',
      lexema: '',
      literal: null,
      linha: 3,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'SENAO',
      lexema: 'senao',
      literal: null,
      linha: 4,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'DOIS_PONTOS',
      lexema: '',
      literal: null,
      linha: 4,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'escreva(',
      literal: 'escreva(',
      linha: 5,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'Não',
      literal: null,
      linha: 5,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'é',
      literal: null,
      linha: 5,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'letra',
      literal: null,
      linha: 5,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'A',
      literal: null,
      linha: 5,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: ')',
      literal: ')',
      linha: 5,
      hashArquivo: undefined
    }
  ]

Já o Avaliador Sintático, por sua vez, vai nos retornar algo mais enxuto:

declaracoes: [
    Var {
      linha: 1,
      hashArquivo: undefined,
      decoradores: [],
      assinaturaMetodo: '<principal>',
      simbolo: [Simbolo],
      inicializador: [Literal],
      tipo: 'texto',
      tipoExplicito: false,
      referencia: false,
      desestruturacao: false
    },
    Se {
      linha: 2,
      hashArquivo: 0,
      decoradores: [],
      assinaturaMetodo: '<principal>',
      condicao: [Binario],
      caminhoEntao: [Bloco],
      caminhosSeSenao: [],
      caminhoSenao: [Bloco]
    }
  ]

Percebe a diferença?

Temos como resultado uma lista das declarações que foram feitas no nosso código: sabemos que existe uma declaração de variável e uma declaração da condicional se, mas não sabemos o que tem dentro de cada uma.

É como se os ramos de uma árvore fossem vistos de longe, ou seja, podemos dizer que o retorno do Avaliador Sintático nos permite ter uma visão da ramificação do código em questão, conseguimos perceber como o código é organizado e hierarquizado.

Neste exemplo, sabemos que a condicional não se limita ao o que é mostrado neste retorno, mas que ela se extende em mais linhas de código, só que, aqui, não temos acesso a esse detalhe. De toda forma, essa AST que o Avaliador Sintático gera vai ser usada pelo Interpretador. Mais adiante, é ele que irá adentrar o “ramo da condicional” e fazer com que o código ali de dentro seja executado (veremos mais detalhes sobre ele num próximo artigo).

Gerando os ramos da AST

ATENÇÃO: Recomendamos que você acompanhe o código do Avaliador Sintático durante a leitura.

Desenvolver uma linguagem de programação é uma atividade um tanto quanto complexa e temos que elaborar com bastante cuidado cada recurso e/ou funcionalidade que queremos empregar nela. Afinal, isso tudo é o que vai nos permitir construir com ela uma infinidade de soluções para sistemas e, para evitar que ocorram inconsistências na linguagem, precisamos ter todo este zelo no seu desenvolvimento.

Cada funcionalidade empregada na linguagem é chamada de “construto” que nada mais é do que os comportamentos que são utilizados para programar em Pituguês e você pode encontrar uma espécie de lista deles neste arquivo.

Para dar um exemplo mais simples, vamos dar continuidade ao método imprima que adicionamos ao Lexador na postagem anterior sobre Pituguês…

Após receber do Lexador os tipos de símbolos no trecho de código (imprima, texto e parênteses esquerdo e direito):

imprima("Agora, você está aprendendo sobre o Avaliador Sintático do Pituguês!")

O Avaliador Sintático recebe esta informação e vai seguir um fluxo de validações para gerar a nossa AST. Vamos entrar em cada uma das funções para gerar este “ramo da árvore” para o nosso método imprima que vai ser mais ou menos nesta ordem:

├── analisar 
│ ├── resolverDeclaracaoForaDeBloco 
│ │ ├── resolverDeclaracao 
│ │ │ ├── declaracaoEscreva 
│ │ │ │ ├── expressao 
│ │ │ │ │ ├── atribuir
│ │ │ │ │ │ ├── chamar
│ │ │ │ │ │ │ ├── primario

OBS.: Durante a explicação da lógica das funções, vamos ignorar alguns trechos de código para tornar a escrita mais concisa.

Função `analisar`

Neste primeiro momento, vamos receber a lista de símbolos do Lexador como argumento na função e vamos inicializar uma lista para abrigar as declarações que serão geradas e formarão a nossa AST:

let declaracoes: Declaracao[] = [];

Logo abaixo, teremos um laço de repetição que permitirá que o Avaliador Sintático siga analisando os símbolos recebidos enquanto não chegar ao final das linhas de código do programa em Pituguês.

O objetivo principal desta função é que os símbolos trazidos pelo Lexador sejam traduzidos em declarações pelo Avaliador Sintático e é isto que será feito dentro deste laço de repetição, pois dentro dele teremos uma linha:

const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();

É aqui que o código vai começar a análise de cada um dos símbolos recebidos para depois instanciarmos o construto referente a declaração que queremos gerar e adicioná-la à nossa lista de declarações.

Função `resolverDeclaracaoForaDeBloco`

Dentro desta função, o objetivo é verificar se a declaração é de uma função, classe, variável ou expressão. Como no caso da nossa linha de código se trata da instrução imprima, que não vai ser classificada como uma função, classe ou variável, vamos adentrar diretamente na função que irá analisar a instrução vigente:

return await this.resolverDeclaracao();

Função `resolverDeclaracao`

Vamos nos deparar com algumas verificações que dizem respeito a variáveis, mas, como não estamos analisando uma variável, a nossa linha de código vai entrar em um switch case, logo abaixo, que irá entrar neste trecho:

case tiposDeSimbolos.IMPRIMA:
case tiposDeSimbolos.ESCREVA:
    const simboloEscrevaOuImprima = this.avancarEDevolverAnterior();
    return this.declaracaoEscreva(simboloEscrevaOuImprima);

No nosso artigo sobre o Lexador, ensinamos que quando uma nova palavra-reservada for incluída, também devemos incluir o seu tipo dentro deste arquivo. É exatamente agora que ele vai ser de suma importância para que o Avaliador Sintático consiga buscar o método que irá verificar se a sintaxe do código foi escrita corretamente e gerar o construto e a declaração em questão para fazer parte da AST.

Antes de irmos adiante no switch case, talvez cause uma ligeira dúvida ao leitor de: “por que estamos sendo direcionados para a função declaracaoEscreva se estamos tratando da função imprima? Por que não uma declaracaoImprima?”.

A linguagem Pituguês, atualmente, é considerada um dialeto de programação e ela foi desenvolvida dentro do código-fonte de Delégua. Muitas características de Delégua foram herdadas pelo Pituguês, juntamente com os padrões de nomenclatura e assinatura dos métodos desenvolvidos para o Avaliador Sintático de Delégua.

Geralmente, quando incluímos um dialeto de progamação no ecossistema de Delégua, vamos fazer com que este dialeto herde a classe Avaliador Sintatico Base que vai trazer para o nosso dialeto a assinatura de diversos métodos a serem implementados e por conta desta herança é que será empregada este padrão de nomes dos métodos. É apenas uma questão organizacional.

De qualquer forma, como o nosso imprima possui o mesmo comportamento do escreva, não precisamos criar um novo método “declaracaoImprima“, por exemplo, para reproduzir esta funcionalidade, basta inserirmos o sinônimo “imprima” no switch case que será direcionado para a construção da declaração em questão.

Função `declaracaoEscreva`

Após ter reconhecido o símbolo imprima, entramos na função que irá construir a declaração do método para adicioná-la à AST.

O que você pode notar é que a função declaracaoEscreva recebe como argumento o símbolo gerado pelo Lexador e que chegou do Avaliador Sintático e, agora, vamos entrar na verificação para garantir que os itens estão na ordem esperada que se possa construir, finalmente, uma declaração para imprima:

Função consumir: apenas tem a finalidade de verificar se o símbolo atual corresponde ao parentese esquerdo que precede o texto que nossa função imprima deverá nos devolver;
const argumentos [...]: aqui, é iniciado uma constante que deverá receber um Array de algum construto. Neste caso, será o nosso texto;
Vamos adentrar um laço de repetição que irá começar a verificação do conteúdo que há após a abertura do parenteses, a fim de validar se temos um dado textual;
Função expressao: ainda estamos dentro de declaracaoEscreva, mas fomos direcionados para a função expressao que apenas irá nos enviar para a seguinte;
Função atribuir: fará uma série de verificações buscando se o símbolo atual, o texto do nosso imprima, é algum tipo de operador (lista de operadores do Pituguês), no entanto, como ele não irá entrar em nenhuma dessas condições, iremos para o próximo método;
Função chamar: esta função tem como objetivo identificar chamadas de funções, acesso de funções, acesso por índice e fatiamentos, porém, caso não se enquadre em nenhuma dessas opções, seremos enviados para a próxima função;
Função primario: finalmente, vamos passar por um switch case para inferir que os argumentos dentro de imprima são do tipo textual, além de retornar e instanciar um construto Literal que é onde estará definido o tipo do dado;
Vamos consumir novamente para verificar se está ocorrendo o fechamento da função com parenteses direito;
E, finalmente, o Avaliador Sintático conseguirá instanciar uma declaracaoEscreva que construirá a função imprima futuramente, o que nos trará o resultado:

declaracoes: [
  Escreva {
      linha: 1,
      hashArquivo: -1,
      decoradores: [],
      assinaturaMetodo: '<principal>',
      argumentos: [Array],
      simboloEscreva: [Simbolo]
  }
],
erros: []

Após todo esse percurso percorrido, voltaremos para dentro da função analisar que terá gerado a nossa declaração para imprima e irá inseri-lá na AST. A geração da AST pode ser percebida no trecho de código:

let declaracoes: Declaracao[] = [];
while (!this.estaNoFinal()) {
    const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
    if (retornoDeclaracao === null) {
        continue;
    }
    if (Array.isArray(retornoDeclaracao)) {
        declaracoes = declaracoes.concat(retornoDeclaracao);
    } else {
        declaracoes.push(retornoDeclaracao as Declaracao);
    }
 // Restante do código [...]
}

Para gerar a AST, depois de concluir todo aquele trajeto para conseguir transformar nosso símbolo numa declaração a partir da função resolverDeclaracaoForaDeBloco e, por fim, enviamos o que foi retornado na variável retornoDeclaracao por todo aquele processo de validação e enviamos para nosso array de declaracoes com um push.

Contribua com o Pituguês!

Agora que você sabe o que é um Avaliador Sintático e como ele funciona no Pituguês, você já está apto a contribuir com ele!

Como comentamos, o código-fonte do Pituguês mora dentro de Delégua, então você irá encontrá-lo neste repositório do GitHub.

Além disso, também preparamos este documento que te guia em como contribuir com a linguagem, em que damos uma visão geral da estrutura do código e os arquivos principais para você contribuir com o Pituguês.

Caso encontre alguma dificuldade, a Design Líquido fez um vídeo demonstrando como contribuir com um Avaliador Sintático e você pode pegar inspirações de lá!

E se você for uma pessoa um pouquinho mais ansiosa e quer entender todas as etapas de desenvolvimento de uma linguagem de programação, te indicamos esta playlist no YouTube da Design Líquido!

Mas com o que posso contribuir?

De diversas formas… você pode usar a linguagem e reportar bugs pra gente, pode divulgar a linguagem e até mesmo fazer contribuições diretas no código-fonte…

💡 Dica:
Para contribuir com o Avaliador Sintático: investigue e analise os construtos que já existem na linguagem, pense o que mais você incluiria e/ou melhoria e vem contar pra gente!

Um pequeno adendo sobre contribuições…

Aderir a boas práticas, registrando no GitHub seu processo de contribuição, é de suma importância! No guia de contribuição que trouxemos para vocês, é ensinado a como buscar por issues para contribuir – ou abrir as próprias issues – e como fazer um PR (Pull Request). Parte da função dessas etapas é deixar documentado e acessível para que outros contribuidores possam acompanhar o desenvolvimento do projeto.

E agora?

Bom, agora que você já sabe como funciona e como se programa um Lexador, te convidamos a aprender e testar o Pituguês! 😉 Escrevemos este tutorial para te ensinar a como programar com ele! Além disso, você sempre pode consultar a documentação!

Neste repositório temos descrito alguns desafios para fazer em Pituguês! E se, por caso, tiver qualquer dificuldade com a linguagem, já pode reportar pra gente que te ajudamos!

O Lexador do Pituguês – Como Contribuir?

Cumbuca Dev — Tue, 24 Feb 2026 16:04:09 +0000

No post anterior sobre como programar o Pituguês, aprendemos que ela é uma linguagem interpretada e que sua arquitetura de projeto é composta por três camadas: o Lexador, o Avaliador Sintático e o Interpretador. Cada uma delas possui sua responsabilidade para que possamos desenvolver uma linguagem de programação e executá-la e, agora, vamos começar a desbravar um pouquinho de cada uma delas, começando por este artigo em que falaremos do Lexador e mostrar um pouquinho como podemos contribuir com o seu código.

Mas, primeiramente…

O que é um Lexador?

Nada mais é do que um programa que irá percorrer e escanear, da esquerda para a direita, os caracteres da nossa linguagem. Nesta etapa, serão identificados os lexemas (que também podemos chamar de símbolos ou tokens) e seu tipo, seu devido significado naquela instrução.

Existem diferentes categorias de símbolos…

Palavras-reservadas

Também chamadas de keywords, são palavras que estão presentes na linguagem de programação e são utilizadas para se escrever instruções do que queremos que nosso programa faça. Por exemplo, palavras como “while“, “for“, “const“, “else” e entre outras que já fazem parte da linguagem e não podem ser usadas para nomear variáveis ou funções.

Aliás, as funções nativas de uma linguagem também são categorizadas como palavras-reservadas e não podem ser usadas para criar alguma outra instrução. Mas, não se preocupe, caso você não saiba que o nome que você deu a uma variável ou função que já exista na linguagem, ela mesma irá te avisar!

Então, tomando como o exemplo o Pituguês, se quisermos desenvolver uma função para inverter a ordem de um vetor e queremos nomeá-la com inverter, não será possível, pois já existe uma função que leva este nome.

Identificadores

É classificação que recebe tudo aquilo que podemos nomear enquanto desenvolvemos um programa! Ou seja, quando damos um nome a uma variável, seu nome é chamado de “identificador”. O mesmo acontece quando nomeamos uma função.

Se criarmos a função…

função somar(valor1, valor2):
    retorna valor1 + valor2

Vamos ter a palavra-reservada função para declaração de funções e, em seguida, o identificador somar. É assim que o Lexador irá reconher o nome da função e categoriza-lo para que seja reconhecido dentro da linguagem.

Constantes

São valores que não sofrem alterações ao longo da execução do programa. Pense que se formos desenvolver um software matemático, o valor do número PI (3,14) jamais poderia ser alterado durante a execução. Linguagens como JavaScript e Delégua permitem que constantes sejam declaradas da seguinte forma:
const valor_de_pi = 3.14;

No entanto, assim como no Python, o Lexador de Pituguês não reconhece ou permite a declaração de constantes como no exemplo de Delégua e JavaScript. Mas isto é algo que pode ser contornado se aplicarmos a convenção do Python no Pituguês que é declarar uma variável em caixa alta:
VALOR_DE_PI = 3.14

Esta convenção fará com que outras pessoas que tiverem contato com o código entendam que aquele dado não deve ser alterado.

Mesmo que o Lexador do Pituguês não seja capaz de reconhecer constantes, achamos que é importante trazer para nossos leitores que elas ainda são uma forma de se identificar e categorizar dados e que, para que seu reconhecimento seja possível, deve ser incluído na programação de um Lexador (afinal, vai que um dia você mesmo queira desenvolver uma linguagem que use constantes…).

Operadores

Outra categoria que um Lexador deve ser capaz de mapear são os operadores. Dentro das linguagens de progamação, teremos:

Operadores Aritméticos: são os símbolos usados para realizar operações matemáticas – adição, subtração, multiplicação, divisão, módulo e exponenciação. Você pode encontrar os operadores aritméticos (ou matemáticos) que existem no Pituguês na documentação;
Operadores Relacionais: são os operadores usados para comparação – igual a, diferente de, maior que, menor que, maior ou igual e etc… também temos eles descritos na documentação do Pituguês;
Operadores Lógicos: podem ser símbolos ou palavras-reservadas em que podemos verificar condições, geralmente retornam os valores verdadeiro ou falso. Os símbolos mais utilizados são: AND, &&, OR, || e ! – mas existem outros mais! Na documentação do Pituguês, temos listados os operadores lógicos e os operadores bit a bit, que também podem se encaixar nesta categoria.

Símbolos Especiais

Geralmente são os símbolos usados na estruturação do programa, por exemplo, quando uma linguagem requer que sua instrução seja terminada em ponto e vírgula, ou que a declaração de vetores exige que seus dados devem estar escrito entre colchetes. Nessas situações, o ponto e vírgula e os colchetes seriam os “símbolos especiais” que fazem parte da estrutura da linguagem para a escrita de comandos.

Lexemas

Nada mais são dos que as strings que correspondem com um típo de símbolo. Por exemplo… quando declaramos uma variável em Pituguês:

nome_da_linguagem = "Pituguês"

Comentamos antes que o nome da variável é reconhecido como identificador, mas ele também vai ser mapeada como um lexema. Então, quando escrevemos esta linha de código em Pituguês e depuramos o Lexador, ele nos trará este retorno:

simbolos: [
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'nome_da_linguagem',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IGUAL',
      lexema: '=',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'Pituguês',
      literal: 'Pituguês',
      linha: 1,
      hashArquivo: undefined
    }
 ]

Note o Lexador nos retorna uma lista de símbolos, em formato json, e cada símbolo é mapeado de acordo com seu tipo e seu lexema. Aqui, o lexema é a declaração literal da escrita da instrução!

Esta etapa é bastante importante para que se tenha a base inicial ao programar uma linguagem de programação, pois a partir da identificação desses lexemas e tipos é que poderemos criar as regras de execução de cada símbolo, baseados na sua função. E isto acontecerá na etapa do Avaliador Sintático.

E como eu posso contribuir com a linguagem Pituguês?

O repositório em que podemos encontrar o Pituguês está disponível no GitHub, dentro do projeto Delégua, então, é dentro desse projeto que podemos fazer contribuições diretamente no Pituguês: é onde está seu código fonte.

Além disso, temos outro repositório em que disponibilizamos um documento que ensina a como contribuir com a linguagem! Lá você vai encontrar um guia de como criar uma conta no GitHub, um passo a passo de como contribuir com a linguagem e como deve registrar sua contribuição na plataforma.

Um pequeno adendo…

Aderir a boas práticas, registrando no GitHub seu processo de contribuição é de suma importância! No guia de contribuição que trouxemos para vocês, é ensinado a como buscar por issues para contribuir – ou abrir as próprias issues – e como fazer um PR (Pull Request). Parte da função dessas etapas é deixar documentado e acessível para que outros contribuidores possam acompanhar o desenvolvimento da linguagem.

Aliás, não apenas para que outras pessoas consigam acompanhar o desenrolar do projeto, mas também é uma forma de mostrar para o mundo o seu trabalho! Aqui na Cumbuca Dev, a gente promove e incentiva a contribuição em projetos de Código Aberto, por ser uma das formas de pessoas iniciantes aprenderem e se desenvolverem na programação, enquanto conquistam experiência real que será super válida para o mercado de trabalho!

Contribuindo com o Lexador!

No documento que contém o guia de como contribuir, temos esta seção que trata da Estrutura do Projeto, nela, temos sinalizados os principais arquivos que estão envolvidos na programação do Pituguês.

Mantendo o foco no Lexador, queremos trazer um exemplo de contribuição que foi implementado por quem vos escreve, a fim de ilustrar brevemente como adicionar uma funcionalidade neste elemento estrutural do dialeto.

No início...

Como Pituguês é um dialeto, muitas estruturas e características acabavam sendo herdadas de Delégua, parecia até uma cópia. O que podemos dizer que “não era considerado muito Pythônico”, uma vez que a proposta do Pituguês é ser um equivalente a Python, enquanto Delégua tem como principais influências Ruby, C# e Kotlin.

Conforme fui estudando mais o dialeto e seu código, identifiquei que o Pituguês usava a mesma função que Delégua: escreva. Então, na época, como Pessoa Iniciante Contribuidora, isto me deixou um pouco inquieta, pois se queremos aproximar o Pituguês do Python, poderíamos buscar traduções equivalentes em casos como este.

Dessa forma, veio a ideia de transformar o escreva em imprima, uma tradução um pouco mais direta do print da linguagem na qual Pituguês se inspira.

Como foi comentado, o Lexador visa identificar os símbolos e seus tipos para que depois sua lógica possa ser implementada no Avaliador Sintático. Precisamos lembrar que o comportamento para uma função chamada imprima já existia na função escreva da linguagem e apenas queríamos adicionar um sinônimo a ela. Portanto, o que precisamos fazer é simplesmente adicionar a palavra “imprima” como uma palavras-reservadas e fazer com que o Lexador a reconheça como parte do Pituguês.

Quais arquivos eu mexo?

Todo o código-fonte da linguagem está dentro do diretório fontes do projeto e como vamos mexer no Lexador do Pituguês, o caminho para chegar até ele é:

fontes > lexador > dialetos > lexador-pitugues.ts

Dentro deste arquivo, você vai encontrar uma função chamada mapear. Imagine que você escreveu a seguinte linha de código:

imprima("Você está aprendendo sobre o Lexador do Pituguês!")

Quando você escreve uma instrução como esta em um editor de código como o VS Code, por exemplo, deve lembrar que escrevemos apenas texto no editor e que esse texto precisa ser traduzido para a linguagem de máquina, como comentamos neste artigo.

Nesse contexto, o Lexador é quem fará a primeira etapa de reconhecimento do que há escrito no código, identificando e retornando os tokens ali presentes, com seus respectivos tipos. Basicamente, neste primeiro momento, precisamos apenas identificar os lexemas que compõe a nossa instrução.

Dentro do Lexador do Pituguês, temos a função mapear para percorrer todas linhas de código escritas no editor, identificando quando aquele comando é iniciado é encerrado. Assim como também verifica a partir de que momento está o início e o final do código por inteiro.

Mas ainda não é aqui que vamos adicionar a palavra-reservada imprima!

Dentro do mapear, temos um trecho de código assim:

while (!this.eFinalDoCodigo()) {
     this.inicioSimbolo = this.atual;
     this.analisarToken();
}

Em resumo, esta instrução está dizendo que “enquanto não for o fim do código, cada token deverá ser analisado”. E é aí aqui que vamos fazer com que o nosso comando imprima seja reconhecido! Através da função analisarToken no Lexador!

Esta função vai capturar caractere por caractere da nossa linha de código e vai buscar identificar cada um deles em um longo switch case. Pode reparar que vamos ter diversos cases para caracteres diferentes (tabulação, espaçamento, nova linha, ponto e vírgula etc). Caracteres correspondentes às categorias que vimos anteriormente no artigo (palavra-reservadas, identificadores, operadores e símbolos especiais). Ou seja, a partir de um momento que o nosso analisarToken consegue identificar um desses caracteres, ele vai verificar se há um tipo de símbolo correspondente ao caractere.

Mas como vamos conseguir identificar a palavra imprima como palavra-reservada dentro deste switch case?

Ainda dentro do analisarToken, no final do switch case, temos:

default:
    if (this.eDigito(caractere)) this.analisarNumero();
    else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
    else {
         this.erros.push({
                   linha: this.linha + 1,
                   caractere: caractere,
                   mensagem: 'Caractere inesperado.',
          } as ErroLexador);
          this.avancar();
    }

Este trecho vai percorrer os caracteres também, mas seu objetivo é identificar o que é número e o que pode ser alguma letra do alfabeto. Inclusive, note que, na terceira linha, temos uma condição que diz que se haver um conjunto de caracteres, deve ser identificada a palavra chave através da função identificaPalavraChave!

Bom… vamos para esta função agora… nela, vai haver uma série de verificações quanto a composição da sequência de caracteres, mas a cereja do bolo está quando ela, finalmente, consegue determinar o lexema neste momento:

const tipo: string =
    textoPalavraChave in palavrasReservadas
         ? palavrasReservadas[textoPalavraChave]
         : tiposDeSimbolos.IDENTIFICADOR;

Aqui temos o que é chamado de “condição ternária” e está sendo verificado se a palavra que foi escrita no código existe ou não enquanto palavra-reservada.

Na segunda linha do trecho de código anterior, temos a constante palavraReservada, em que temos dentro dela uma lista de palavras-reservadas. Esta constante é importada de um outro arquivo que está no caminho:

fontes > lexador > dialetos > palavras-reservadas > pitugues.ts

Dentro da constante, vamos adicionar o nosso “imprima”, porém… temos que declará-lo neste formato:

imprima: tiposDeSimbolos.IMPRIMA

Você pode conferir a lista de palavras-reservadas neste link do GitHub.

Adicionar o imprima nesta lista de palavras-reservadas ainda não é o suficiente, temos que adicionar, também, na lista de objeto tiposDeSimbolos que está no arquivo:

fontes > tipos-de-simbolos > pitugues.ts

Você pode dar uma olhadinha neste arquivo para conferir o formato que devemos adicionar o nosso tipo de símbolo que é:

IMPRIMA: 'IMPRIMA'

Testando nossa adição

Seguindo todos esses passos, você já pode adicionar uma nova palavra-reservada no Lexador do Pituguês, mas a gente ainda precisa garantir que ela está sendo reconhecida pela linguagem e sendo executada corretamente.

Agora, vamos ir para nosso arquivo de teste do Lexador de Pituguês que você pode encontrar no seguinte caminho, já saindo do fontes:

testes > lexador > dialetos > pitugues > lexador.test.ts
Já dentro do arquivo, queremos saber se o Lexador já está identificando imprima como nova palavra-reservada, então devemos elaborar um teste unitário e executá-lo:

it('Sucesso - imprima', () => {
    const resultado = lexador.mapear(
        ["imprima('Você está aprendendo sobre o Lexador do Pituguês!')"],
        -1
    );
    expect(resultado).toBeTruthy();
    expect(resultado.simbolos).toHaveLength(4);
    expect(resultado.simbolos).toEqual(
        expect.arrayContaining([
            expect.objectContaining({ tipo: 'IMPRIMA' }),
            expect.objectContaining({ tipo: 'PARENTESE_ESQUERDO' }),
            expect.objectContaining({ tipo: 'TEXTO' }),
            expect.objectContaining({ tipo: 'PARENTESE_DIREITO' }),
        ])
    );
  });

No teste para o Lexador, note que estamos apenas verificando se contém os tipos de símbolos esperados naquela linha de código. É apenas isto que precisamos fazer com o Lexador: verificar se nossos símbolos estão sendo reconhecidos como previsto.

Após adicionar o teste, logo acima dele, no VS Code, você verá escrito Run | Debug e você pode clicar no Run para executar o teste e ver se ele é aprovado. Caso ele passar nos testes unitários, podemos enviar nossa contribuição para o repositório do projeto.

A Design Líquido já fez um vídeo ensinando a programar um Lexador neste vídeo do YouTube! Você pode dar uma conferida nele para ver como é todo o processo em ação.

Lembrando que também temos este guia de como você pode fazer sua contribuições no código-fonte da linguagem!

E agora?

Neste repositório temos descrito alguns desafios para fazer em Pituguês! E se, por caso, tiver qualquer dificuldade com a linguagem, já pode reportar pra gente que te ajudamos!

Como programar uma linguagem de programação? - Pituguês

Cumbuca Dev — Fri, 06 Feb 2026 17:53:27 +0000

Há poucos tempo, trouxe aqui para o TabNews uma apresentação e tutorial da linguagem Pituguês. Mas lembram que também contamos que seu código-fonte é aberto? Isto significa que qualquer pessoa pode participar do desenvolvimento da linguagem, é o que chamamos de “Comunidade de Código Aberto (ou Open Source)”.

E como faço para participar da Comunidade de Código Aberto?

Basta se voluntariar para ajudar em algum projeto que você tenha interesse e buscar formas de contato com as pessoas que já estão envolvidas com o projeto, seja por fóruns, redes sociais, e-mails e etc.

Nesse sentido o GitHub também cumpre um papel importante para projetos de código aberto, pois podemos fazer discussões por lá, escrever documentação dos projetos, fazer nossas contribuições, deixar organizado e registrado o que e como a comunidade pode ajudar e por aí vai…

As participações vão desde comentários, trazer suas dúvidas, sugestões, reportar imprevistos ao usar a linguagem, escrever e divulgar sobre ela ou, caso a pessoa se sinta a vontade, pode ajudar fazendo alterações no próprio código fonte da linguagem. Dentro do Código Aberto, cada pessoa pode colaborar com o pouquinho que lhe cabe e toda a contribuição é importante, válida e ajuda o projeto a crescer!

E como contribuir com o Pituguês?

Primeiramente, precisamos entender onde está o Pituguês!

O Pituguês é uma das linguagens de programação que existem dentro de um projeto maior que é a linguagem Delégua. Como o código-fonte de Pituguês está em Delégua, podemos dizer que ele é, até o momento, mais um “dialeto de programação”, pois ele acaba por ser uma variante de uma linguagem maior.

Dialetos nada mais são do que variações de uma mesma língua, e na programação essa lógica também se aplica. Pense em um país continental como o Brasil, dividido em 5 regiões e com 27 estados (incluindo o Distrito Federal). Embora existam discussões no campo da linguística se as variações do português no Brasil sejam dialetos ou apenas sotaques, é inegável que podemos notar diferenças bem acentuadas de expressões, palavras e entonações entre regiões diferentes ao ponto de um nortista ter dificuldade de entender a fala de um sulista e vice-versa. Esta pequena diferença linguística entre pessoas oriundas de diferentes regiões de um mesmo país, que geram um contratempo comunicacional, pode ser classificada como um dialeto.

E, talvez você não saiba, mas já tenha tido contato com dialetos de outras linguagens de programação! Podemos dizer que TypeScript seria um dialeto de JavaScript, por exemplo, uma vez que usa toda a sintaxe do JavaScript e adiciona a tipagem à linguagem.

Outro exemplo interessante são os dialetos PL/SQL e PL/pgSQL que unem a lógica de programação procedural com linguagem de consulta. Se você for comparar, eles são bastante similares, mas ainda possuem diferenças em sua sintaxe que são bem características e que demarcam sua distinção.

Se formos comparar as funções nativas de Delégua e Pituguês, percebemos que ambas possuem funções com nomes iguais ou semelhantes. No entanto, a forma de declaração de variáveis e definição de bloco de código são diferentes.

Delégua

Declaração de variáveis requer a palavra-reservada var
Blocos de código são definidos entre par de chaves { }

Pituguês

Seguimos o modelo de Python em que apenas nomeamos a variável e atribuímos um valor
Blocos de código são definidos após dois pontos e identancão

Onde fica o código-fonte de Pituguês e como ele é organizado?

Comentamos repetidas vezes que ele é um dialeto de Delégua e que vive dentro do código-fonte de Delégua. Você pode encontrar o repositório do núcleo de Delégua disponível no Github e, além disso, também está disponibilizado este tutorial de como contribuir com o Pituguês.

Mas, antes, o que a gente precisa entender é como a linguagem tem seu código arquitetado e organizado! Lembrando que estamos programando uma linguagem de programação e que existem dois tipos principais de linguagens de programação: a compilada e a interpretada.

Linguagem Compilada

Geralmente, quando construímos um software, a pessoa desenvolvedora irá escrever o código do programa com o que chamamos de “linguagem de alto nível”. Isto significa que se trata de uma linguagem de programação mais próxima à linguagem humana, de mais fácil leitura e entendimento para quem está lidando com aquele código.

Por essa lógica, podemos presumir que “quanto mais baixo o nível, mais distante da linguagem humana”… O que é bem verdade!

Só que quando programamos algo, estamos criando programas para serem executados em máquinas e elas não falam a mesma língua que a gente! Elas só entendem linguagens de baixo nível, que vem a ser o que chamamos de “linguagem de máquina” ou “linguagem binária”.

É a famosa linguagem composta de zeros e uns, em que eles representam o estado da eletricidade – desligado ou ligado. Convenhamos que ela realmente não é muito acessível para se escrever um programa…

O ponto é que, nas linguagens compiladas, a gente consegue escrever programas de uma forma que é acessível para pessoas, mas ainda não é para a máquina. Então, após o programa ser desenvolvido por inteiro, é aí que entra o papel do compilador que vai fazer no nosso código passar por um processo que, normalmente, é chamado de “build” (construir) e que irá traduzir o nosso código da linguagem humana para a linguagem de máquina. Só assim vamos conseguir executar o programa na máquina.

E isso pode acontecer sucessivamente, pois cada vez que identificamos algum bug ou queremos atualizar ou editar algo no código, vamos ter que fazer todo esse processo de reconstruir o código para criar um arquivo executável dele que a máquina consiga rodar.

Um detalhe bastante interessante é que as linguagens compiladas elas te ajudam a identificar erros de sintaxe na escrita do código, pois, se houver qualquer erro, elas vão impedir o processo de compilação – a construção do programa -, já que ele não conseguirá ser executado de jeito nenhum.

Linguagem Interpretada

Já aqui, nas linguagens interpretadas, ainda que o programa precise ser traduzido para código de máquina, as instruções serão executadas ao mesmo tempo em que a linha de código é lida. É como se fosse uma tradução simultânea.

As linguagens compiladas nos avisam quando encontram um erro que as impede de construir o programa. Já as linguagens interpretadas, quando o interpretador esbarra numa linha de código que possui um bug, ou alguma inconsistência, simplesmente quebram e interrompem o a execução.

Por um lado, ela nos dá uma certa vantagem de que não precisamos compilar nosso código, reconstruindo o programa, toda vez que for necessário fazer alguma alteração nele. Ela acaba nos dando mais flexibilidade e agilidade na edição do algoritmo, embora sua execução possa ficar um pouco comprometida.

Outra diferença importante é que o interpretador pode tanto traduzir a linguagem de alto nível direto para a linguagem de máquina, como pode haver uma linguagem intermediária que esta irá traduzir para o código de máquina.

Afinal, como é programado o Pituguês?

Bom, acabamos de ver, de forma resumida, quais são os dois principais de tipos de linguagens de programação. E isso é bastante importante para sabermos como programar a nossa linguagem!

Mas… qual delas é o Pituguês?

No próprio código-fonte, é descrito como é organizada a arquitetura da linguagem, com os componentes: lexador, avaliador sintático e, finalmente, interpretador. Dessa forma, podemos presumir que ela é uma linguagem interpretada, uma vez que sua arquitetura possui um interpretador.

Cada um dos componentes mencionados é responsável por uma etapa do processo que faz com que as instruções escritas em Pituguês sejam traduzidas para o código de máquina, permitindo que um programa desenvolvido nesta linguagem possa ser efetivamente executado. Vamos entender um pouquinho deles…?

Lexador

A Design Líquido escolheu a palavra “Lexador” para traduzir o que normalmente é chamado de “Lexer” e/ou “Tokenizer”, mas você ainda pode encontrar outras traduções que irão usar o termo “Analisador Léxico” e/ou “Tokenizador”.

E qual é a função dele aqui?

Bom, pense que as linguagens de programação possuem símbolos e termos específicos que usamos para conseguirmos elaborar instruções e construir um programa para a finalidade que queremos. Todo esse arcabouço de recursos precisa ser mapeado e reconhecido como um item que faz parte daquela linguagem e é o Lexador que cumprirá este papel.

Por exemplo, quando queremos declarar uma variável no Pituguês:

nome_da_linguagem = "Pituguês"

O Lexador vai percorrer cada caractere existente nesta linha de código e mapear cada elemento e sua devida função no código, então, teremos:

“nome_da_linguagem”: será reconhecido como o “identificador”, o nome da variável;
“=”: a maioria das pessoas nomeia este símbolo como “sinal de igual”, mas no contexto da declaração de variável, o Lexador deverá identifica-lo como um “sinal de atribuição”, pois após ele deverá ser escrito o valor que aquela variável conterá;
“Pituguês”: finalmente temos o valor que será guardado pela variável e, neste caso, como o Pituguês é capaz de identificar o tipo de dado por si mesmo, a própria linguagem deverá presumir que se trata de um tipo textual.

Ou seja, para o Pituguês aceitar a declaração de uma variável, o Lexador deve conseguir mapear cada um destes elementos, caso contrário, por ser uma linguagem interpretada, o programa irá interromper sua execução abruptamente, enquanto está em processo de execução. Esta mesma lógica é empregada para todas as outras palavras reservadas e símbolos que compõem a linguagem.

Avaliador Sintático

O Avaliador Sintático é a parte do processo que irá fazer a “análise sintática”, identificando se os símbolos estão dispostos na ordem adequada para serem reconhecidos enquanto sentenças que fazem parte da linguagem em questão. Ele vai receber do Lexador os símbolos mapeados e verificar se eles estão estruturados de uma maneira que faça sentido para que se possa executar as instruções do programa.

E por que essa etapa é tão importante?

Pense que o único propósito do Lexador é mapear e identificar os tipos de símbolos. Vamos supor que tentamos declarar uma variável escrita na seguinte maneira:

var nome_da_linguagem = "Pituguês"

Note que adicionamos a palavra ‘var’ antes do identificador da variável, ‘nome_da_linguagem’, o Lexador ainda consegue reconhecer e identificar os símbolos que existem nesta sequência textual, porém, o Avaliador Sintático vai impedir que esta linha de código seja executada, pois ela não será reconhecida como uma sentença válida.

E o que faz o Avaliador Sintático reconhecer uma instrução possível ou não? A sua programação! É dentro deste componente estrutural da linguagem de programação que elaboramos e verificamos quais instruções serão válidas: nós programamos o Avaliador Sintático para que não reconheça “var” enquanto uma palavra reservada para declaração de variáveis.

Esse tipo de comportamento é equivalente ao que encontramos num idioma, por exemplo, ao ler a sentença “Eu batata programo em Pituguês”. Note que temos uma palavra inserida que não faz sentido para a mensagem da frase. Podemos dizer que ela não está seguindo as regras gramaticais do português, uma vez que tempos uma palavra extra deslocada na frase.

Agora, se escrevermos “eu programo em Pituguês”, os termos estarão conectados e relacionados, tornando a mensagem compreensível! Da mesma forma acontece com linguagens de programação: seguir suas regras gramaticais é essencial para que se possa construir um programa!

Interpretador

Esta é a etapa da nossa arquitetura que será responsável pela execução do código! Como mencionamos antes, um interpretador é como se fosse uma tradução simultânea em que, conforme nosso interpretador vai lendo linha a linha, suas instruções vão sendo verificadas pelo Avaliador Sintáitco e, se estiverem na estrutura esperada da linguagem, serão executadas.

Para que a execução seja efetuada, partimos do princípio em que nosso código passou pela aprovação do Lexador e do Avaliador Sintático e, agora, o Interpretador, também, precisará contribuir com a sua aprovação.

Mas como isso é feito?

Ele irá receber as declarações que foram identificadas no Avaliador Sintático e que estão seguindo as regras gramaticais esperadas. Caso a gramática não esteja de acordo, é o momento em que a nossa “tradução simultânea” será interrompida abruptamente e a linguagem retornará um erro para nós.

Devemos lembrar que o Avaliador Sintático fez a verificação gramatical das instruções em Pituguês e, se ela corresponder às normas esperadas, irá gerar uma espécie de Árvore de Análise Sintática, também conhecida como Árvore de Derivação. É papel do Interpretador percorrer essa “árvore” e verificar qual instrução está sendo chamada para execução e, para desempenhar esta função, o Interpretador vai usar um “Design Pattern” conhecido como “Visitor Pattern”, ou “padrão Visitante”.

É com o padrão Visitante é que o interpretador poderá buscar e identificar a instrução escrita em Pituguês a partir de Árvore de Análise Sintática, no entanto, estes conceitos são um pouco mais complexos e sua aplicabilidade para o Pituguês será tratada mais futuramente. Mas… caso você tenha interesse em já ir conhecendo um pouquinho mais deles, recomendamos a leitura do artigo Visitor do refactoring.guru e o trecho de Análise Sintática do ebook Compiladores para Humanos.

Recomendamos fortemente que eassista este vídeo, produzido pela Design Líquido, demonstrando como cada etapa funciona e se complementa – Lexador, Avaliador Sintático e Interpretador. No vídeo, a demonstração é com a linguagem Delégua, mas a mesma estrutura é utilizada na programação do Pituguês e pode ficar mais claro para você ao ver cada etapa em ação!

E, só pra reforçar, como vimos antes, nas linguagens interpretadas, elas podem traduzir nosso código diretamente para o código de máquina, ou podem ter um código intermediário que a traduz para o código de máquina.

No caso do Pituguês, ela é uma linguagem de programação desenvolvida em TypeScript que passará direto para o JavaScript, que é uma linguagem de característica híbrida, o que chamamos de Just In Time Compilation (JIT), para traduzir/transpilar o Pituguês para a linguagem de máquina e ser executado. O processo de transpilação do JavaScript se dá por uma Máquina Virtual, chamada de V8, para criar o código de máquina e rodar o programa.

Ou seja, o Pituguês precisa de um intermediário para traduzir seu código em código de máquina e tornar possível a execução de um programa, percorrendo um caminho mais ou menos assim:

Falando sobre o futuro…

Até a escrita deste artigo, como comentamos repetidamente, Pituguês é considerado um dialeto, uma vez que ele vive dentro do código-fonte de Delégua. Por ele se encontrar dependende do núcleo de outra linguagem, acaba por ter certas limitações no seu desenvolvimento, principalmente por ambas compartilharem do mesmo Interpretador.

Acreditamos que para maior expansão do Pituguês, ele precise “caminhar com suas próprias pernas” e ser oficialmente uma linguagem!

Gostaríamos de promover a independência do Pituguês para que, assim como em Python, a comunidade possa ter mais liberdade de contribuir e incrementar tudo aquilo que for benéfico para seus usuários! E, principalmente, sem a preocupação do quanto as contribuições possam afetar outro projeto.

Te convidamos a trocar uma ideia com a gente futuro do Pituguês neste fórum do GitHub!

Inicialmente, queremos propor as discussões:

Quais os primeiros passos para tornar o Pituguês independente?
Como podemos projetar esta linguagem?
Aliás, em qual linguagem de programação devemos programar o Pituguês? Continuaríamos com TypeScript ou seria mais interessante escolher outra e por quê?
Materíamos a arquitetura de: Lexador, Avaliador Sintático e Interpretador?

Programando em Pituguês! - Uma linguagem inspirada em Python

Cumbuca Dev — Wed, 28 Jan 2026 17:43:48 +0000

⚠️ Atenção: Esse texto é uma introdução e tutorial! Divirta-se! :)

Quando começamos a aprender a programar, uma das primeiras descobertas que nos deparamos é que: as linguagens de programação são todas em inglês! Bom, pelo menos as que são utilizadas no mercado de trabalho.

Estatisticamente falando, apenas 5% dos brasileiros entendem inglês em algum nível, enquanto apenas 1% possui fluência. Ou seja, nem todos os falantes de língua portuguesa tem conhecimento do idioma inglês.

O que faz com que a pessoa aprendiz passa encontrar barreiras que a faça dispor mais esforço para desenvolver várias habilidades ao mesmo tempo (programar e aprender outro idioma concomitantemente). Ela terá dificuldades de lidar com recursos e instruções da linguagem de programação, o que poderá comprometer sua aprendizagem de lógica e algoritmos.

Aí tem-se a importância de existir uma linguagem como o Pituguês, em que a pessoa nativa em português consiga programar em sua língua mãe, eliminando a barreira idiomática.

Mas de onde vem o Pituguês?

Sua sintaxe é inspirada na da linguagem de programação Python que, embora seu nome faça alusão a uma espécie de cobra e seu símbolo seja composto de duas cobras em Ying & Yang, seus criadores eram muito fãs da série de comédia “Monty Python’s Flying Circus” e batizaram a linguagem com o nome de “Python”.

Pegando carona até mesmo no nome, se formos traduzir “python”, temos “píton”. Assim, para trazer a ideia de uma linguagem de programação inspirada em Python para a língua portuguesa, uniu-se “píton” + “português” que resultou em: Pituguês!

E, como comentamos, o Pituguês vai se inspirar e buscar trazer características do Python para português, como…

Tipagem Dinâmica

Quando lidamos com linguagem de programação, devemos lembrar que existem tipos diferentes de dados, como dados textuais, numéricos, binários e etc.

Algumas linguagens exigem que o tipo de dado seja declarado como, por exemplo, em Java, declaramos uma variável da seguinte maneira…

int numero = 2025;
String nome = "Java";

Note que, em Java, indicamos o tipo do dado (int, para números inteiro, e String para tipos textuais), escrevemos o nome da variável e, por fim, damos um valor a ela. Se formos comparar com Python, já possui uma diferença acentuada…

numero = 2025
nome = "Python"

Como podem ver, já não é necessário indicar o tipo da variável, pois a linguagem irá verificar isso automaticamente, é o que chamamos de “inferir tipo”.

No Pituguês, não vai ser diferente, a nossa declaração de variáveis também vai inferir o tipo...

numero = 2025
nome = "Pituguês"

Indentação

A indentação nada mais é que o aninhamento de trechos de código que, no caso do Python, se dá através da tabulação (4 espaçamentos), ela tem o objetivo de determinar quais linhas de código pertencem a um bloco lógico, definindo a estrutura e hierarquia.

Ou seja, declaramos uma função, por exemplo, em seguida, escrevemos os dois pontos e, logo abaixo deles, com certo espaçamento, começamos a escrever o que a nossa função irá executar. Dessa forma que definimos o escopo e a hierarquia do código, determinando em que momento o trecho de código é iniciado e finalizado.

Caso a indentação não seja feita da maneira correta, sem o espaçamento ou com espaçamento excessivo, o próprio Python irá nos sinalizar com uma mensagem de erro.

Na documentação do Pituguês você consegue ter acesso a exemplos de como a indentação funciona:

Pituguês X Python

Assim como o Python, o Pituguês também é uma linguagem de Código Livre e está aberta a contribuições e, deste a postagem original deste tutorial e introdução a respeito da linguagem, já aconteceram mudanças bastante significativas...

Declaração de Variáveis

Há pouco tempo atrás, Pituguês adicionava a palavra var na declaração de variáveis, o que o distanciava de Python. No entanto, contribuições mais recentes da comunidade fizeram que consigamos declarar variáveis da mesma forma que em Python:

linguagem_de_programacao = "Pituguês"

Interpolação de Texto

Em resumo, Pituguês existe no repositório de uma outra linguagem de programação em português chamada Delégua e acabou herdando algumas características dela, como a interpolação:

var linguagemDeProgramacao = "Delégua"
escreva("Linguagem de programação: ${linguagemDeProgramacao}")

Este tipo de interpolação também se distanciava do Python, mas contribuições recentes trouxeram proximidade entre Pituguês e Python e, agora, a interpolação segue o padrão f-strings:

linguagem_de_programacao = "Pituguês"
imprima(f"Linguagem de programação: {linguagemDeProgramacao}")

Lembrando que estamos atualização a documentação do Pituguês constantemente e, qualquer dúvida que senha sobre a sintaxe, basta consultá-la!

Mas como programar em Pituguês?

Para programar em Pituguês, basta que você instale uma extensão no VS Code. Se na aba de extensões você procurar por "pitugues", deve encontrar a extensão da Design Líquido que possui todo um ecossistema de linguagens em português como: linguagem de programação, de marcação, de estilo, de consulta e etc.

Nesta postagem você pode encontrar um tutorial semelhante a este, mas que demonstra por imagens como instalar a extensão e como executar seus programar em Pituguês!

Lembrando...

O Pituguês é uma iniciativa feita pela comunidade, para a comunidade e toda contribuição conta! 🐍💜
É uma linguagem que está em constante transformação e vocês podem acompanhar junto com a gente todo esse processo!

Junte-se a nós e ajude a construir o Pituguês — uma linguagem feita com comunidade, propósito e muito coração. 💜

Hackeando o Inglês: Programando na Língua em que Você Pensa

Cumbuca Dev — Wed, 28 Jan 2026 17:34:31 +0000

Ingressar no mercado de tecnologia, cujo idioma utilizado nas linguagens de programação é o inglês costuma ser bastante desafiador para quem ainda não tem conhecimentos da língua. É um cenário que força pessoas iniciantes a aprenderem duas habilidades ao mesmo tempo: a lógica de programação e um novo idioma. E, convenhamos, não são habilidades triviais de aprender…

A barreira idiomática é uma das causas de desistência de muitas pessoas iniciantes na programação. Imagino que você mesmo tenha tido contato com alguém que comentou sobre a dificuldade com o inglês enquanto tentava aprender a programar, não?

Buscando ultrapassar essa barreira, a Cumbuca Dev e a Design Líquido se uniram para oferecer ferramentas e conteúdo de capacitação técnica que são acessíveis a pessoas falantes da língua portuguesa e podem ser
usadas para fins educacionais ou comerciais e, acima de tudo, são Open Source.

Mas quais são a vantagens de se programar em português, afinal?

Facilita a Localização de Erros: Programar em português pode tornar mais fácil a localização e correção de erros de código, uma vez que as pessoas desenvolvedoras podem compreender rapidamente o contexto dos problemas;
Acessibilidade e Compreensão: Programar em sua língua materna, como o português, torna os conceitos de programação mais acessíveis e fáceis de entender, especialmente para iniciantes, reduzindo a barreira de entrada para novas pessoas programadoras;
Facilita o Aprendizado: A programação em português permite que as aprendizes concentrem-se nos conceitos de programação em vez de lidar com a barreira de um segundo idioma. Isso pode acelerar o processo de aprendizado, especialmente para pessoas que não têm fluência em inglês (considerando que cerca de 95% dos falantes de português nunca tiveram contato com a língua inglesa);
Melhor Comunicação e Documentação: Programar em seu idioma nativo leva a uma comunicação mais clara e eficaz com colegas e clientes locais. Além disso, a documentação em português é mais fácil de compreender e seguir;
Contribuição para a Identidade Cultural: Linguagens de programação em português contribuem para a preservação e fortalecimento da identidade cultural e linguística, promovendo o uso e a adoção do idioma em contextos tecnológicos;

Agora, vamos conhecer um pouco mais do ecossistema?

Delégua

Uma linguagem com sintaxe totalmente em português, pensada para tornar a programação mais próxima, inclusiva e acessível para quem fala a nossa língua.
E vai muito além do educacional: com Delégua e o ecossistema da Design Líquido, você pode construirprojetos reais e profissionais 100% em português!

LMHT

Inspirada no HTML, LMHT propõe uma estrutura de marcação totalmente em português, facilitando a compreensão e utilização por falantes da nossa língua.
Mais do que uma ponte para quem está começando, a LMHT é uma ferramenta prática para a criação de páginas e sistemas reais, sem barreiras idiomáticas.

FolEs

FolEs é a linguagem de folhas de estilo do ecossistema Design Líquido, análoga ao CSS, com sintaxe em português.
Pronta para uso profissional, também torna o aprendizado de estilização muito mais acessível!

LinConEs

Linguagem de consulta de banco de dados inspirada no SQL, com comandos e estruturas em português, tornando o trabalho mais acessível para quem fala a nossa língua.
Amplia as oportunidades na área de dados, democratizando o acesso a uma das habilidades mais valorizadas no mercado de tecnologia.

Líquido

E, finalmente, o framework que conecta todas as tecnologias da Design Líquido! Com ele, é possível desenvolver aplicações web com um código 100% em português!
Reúne linguagens, ferramentas e documentação pensadas para tornar o desenvolvimento acessível
em português, desde o aprendizado até a produção de soluções profissionais.

Lembrando que esse ecossistema é de código aberto e você pode encontrá-los neste link!

Além disso, você também pode contribuir e ajudar os projetos a crescerem!

Contribuir com projetos de Código Aberto pode ser uma ótima porta de entrada para uma pessoa iniciante construir experiência, aprender junto à comunidade de código aberto e aumentar network. E, para além da experiência, participar do desenvolvimento de projetos assim tem um gostinho especial de estar construindo algo real e útil que pessoas que nem imaginamos podem se beneficiar!

A Design Líquido e a Cumbuca Dev acreditam e praticam o código aberto como filosofia de trabalho. *Todo esse ecossistema é feito pela comunidade e para a comunidade!
*
Por isso, queremos te convidar a explorar, usar, construir e contribuir com estes projetos! Eles existem para beneficiar nós, falantes da língua portuguesa, tornando mais acessível o ensino e a prática da programação.

Só assim, em unidade, podemos construir ferramentas que correspondam à nossa realidade!

E, só para dar aquela reforçadinha: você pode encontrar todos estes projetos no GitHub da Design Líquido com toda a documentação de como utilizar e como contribuir, além do canal no YouTube que contém uma série de vídeos demonstrativos, que explicam a estrutura de cada um desses projetos.

Se você gostou do ecossistema e também acredita que o inglês pode ser uma barreira: dê uma estrela nos repositórios do GitHub ⭐ Isso ajuda mais pessoas a conhecerem este ecossistema e pode abrir portas para quem busca uma entrada na tecnologia.

DEV Community: Cumbuca Dev

Executando uma Linguagem Interpretada - Pituguês

Impacto da Linguagem Interpretada

Uma linguagem interpretada em português

O Interpretador

Executando a AST

Visitor Pattern - ou Padrão Visitante

1. Visitor Interface (Interface dos Visitantes)

2. Concrete Visitors (Visitantes Concretos)

3. Visitable Elements (Elementos Visitáveis)

Visitando as Declarações

1. Testes do Interpretador do Pituguês

2. Função interpretar da classe Interpretador

3. Função interpretar da classe InterpretadorBase

4. Função executarUltimoEscopo da classe Interpretador

5. Função executar da classe InterpretadorBase

6. Função aceitar nas classes Var e Se

7. Funções visitarDeclaracaoVar e visitarDeclaracaoSe

Contribua com o Pituguês!

Mas com o que posso contribuir?

Um pequeno adendo sobre contribuições...

E agora?

Avaliador Sintático: Como Funciona no Pituguês

Retomando alguns conceitos…

Como o Avaliador Sintático avalia os tokens do Lexador?

Composição de um programa

Estrutura de Dados em Árvore

A AST do Avaliador Sintático

Gerando os ramos da AST

Função analisar

Função resolverDeclaracaoForaDeBloco

Função resolverDeclaracao

Função declaracaoEscreva

Contribua com o Pituguês!

Mas com o que posso contribuir?

Um pequeno adendo sobre contribuições…

E agora?

O Lexador do Pituguês – Como Contribuir?

O que é um Lexador?

Palavras-reservadas

Identificadores

Constantes

Operadores

Símbolos Especiais

Lexemas

E como eu posso contribuir com a linguagem Pituguês?

Um pequeno adendo…

Contribuindo com o Lexador!

No início...

Quais arquivos eu mexo?

Testando nossa adição

E agora?

Como programar uma linguagem de programação? - Pituguês

E como faço para participar da Comunidade de Código Aberto?

E como contribuir com o Pituguês?

Primeiramente, precisamos entender onde está o Pituguês!

Delégua

Pituguês

Onde fica o código-fonte de Pituguês e como ele é organizado?

Linguagem Compilada

Linguagem Interpretada

Lexador

Avaliador Sintático

Interpretador

Falando sobre o futuro…

Programando em Pituguês! - Uma linguagem inspirada em Python

Mas de onde vem o Pituguês?

Tipagem Dinâmica

Indentação

Pituguês X Python

Declaração de Variáveis

Interpolação de Texto

Mas como programar em Pituguês?

Lembrando...

Hackeando o Inglês: Programando na Língua em que Você Pensa

Mas quais são a vantagens de se programar em português, afinal?

Agora, vamos conhecer um pouco mais do ecossistema?

Delégua

LMHT

FolEs

2. Função `interpretar` da classe `Interpretador`

3. Função `interpretar` da classe `InterpretadorBase`

4. Função `executarUltimoEscopo` da classe `Interpretador`

5. Função `executar` da classe `InterpretadorBase`

6. Função `aceitar` nas classes `Var` e `Se`

7. Funções `visitarDeclaracaoVar` e `visitarDeclaracaoSe`

Função `analisar`

Função `resolverDeclaracaoForaDeBloco`

Função `resolverDeclaracao`

Função `declaracaoEscreva`