Introdução

Neste tutorial, vamos explorar o desenvolvimento prático com a linguagem de programação Modula-2, uma linguagem projetada para suportar a programação modular e o desenvolvimento de aplicações robustas. Embora menos comum em comparação com outras linguagens, Modula-2 ainda possui um espaço relevante em áreas específicas, como sistemas embarcados e programação de sistemas críticos. Abordaremos as ferramentas disponíveis para o desenvolvimento em Modula-2, discutiremos a interoperabilidade com outras linguagens e exploraremos como estruturar projetos modernos utilizando conceitos de engenharia de software. Ao final, você terá uma compreensão sólida do potencial de Modula-2 e estará preparado para implementar aplicações práticas utilizando essa linguagem.

Etapas

  1. Instalação das Ferramentas Necessárias

    Antes de começar a programar em Modula-2, você precisará de um compilador e de um ambiente de desenvolvimento. Um dos compiladores populares é o GNU Modula-2 (GM2). Siga as instruções abaixo para instalação.

    commands
    # Verifique se o git está instalado
    git --version
    # Clone o repositório GM2
    git clone https://github.com/GM2/GM2.git
    # Acesse o diretório do GM2
    cd GM2
    # Compile e instale o GM2
    make && sudo make install

  2. Criando seu Primeiro Programa Modula-2

    Vamos criar um simples programa “Hello, World!” para garantir que sua configuração está correta. Crie um arquivo chamado `HelloWorld.Mod` com o seguinte código.

    HelloWorld.Mod
    MODULE HelloWorld;

IMPORT Out;

BEGIN
  Out.String("Hello, World!");
  Out.Ln;
END HelloWorld.

  3. Compilando o Programa Modula-2

    Agora que você tem seu programa, o próximo passo é compilá-lo. Use o compilador GM2 para compilar seu código.

    commands
    # Compile o arquivo HelloWorld.Mod
    gm2 HelloWorld.Mod -o HelloWorld
    # Execute o programa compilado
    ./HelloWorld

  4. Estruturando Projetos Modernos em Modula-2

    Para projetos maiores, é importante ter uma estrutura de diretórios adequada. Vamos criar uma estrutura básica de projeto com módulos separados.

    commands
    # Crie a estrutura de diretórios
    mkdir -p my_project/src my_project/lib
    # Crie um arquivo de módulo chamado Math.Mod para operações
    echo 'MODULE Math;

EXPORT ADD;

PROCEDURE ADD(a, b: INTEGER): INTEGER;
BEGIN
  RETURN a + b;
END ADD.' > my_project/src/Math.Mod

  5. Implementando o Uso de Módulos

    Complementando nosso projeto, vamos criar um módulo principal que utilize o módulo Math que acabamos de criar. Crie um arquivo `Main.Mod`.

    Main.Mod
    MODULE Main;

IMPORT Out, Math;

VAR
  result: INTEGER;

BEGIN
  result := Math.ADD(5, 10);
  Out.Int(result, 0);
  Out.Ln;
END Main.

  6. Compilando e Executando Múltiplos Módulos

    Para compilar o projeto que possui múltiplos módulos, você deve compilar todos os módulos juntos. Use o seguinte comando para compilar e executar o programa principal.

    commands
    # Compile ambos os módulos
    gm2 my_project/src/Main.Mod my_project/src/Math.Mod -o my_project/main
    # Execute o programa principal
    ./my_project/main

  7. Testes em Modula-2

    Embora a cultura de testes unitários não seja tão comum em Modula-2, você pode implementar testes práticos de forma simples. Vamos criar um módulo de teste.

    TestMath.Mod
    MODULE TestMath;

IMPORT Math, Out;

BEGIN
  Out.String("Testando Math.ADD:");
  Out.Ln;
  Out.Int(Math.ADD(2, 3), 0);
  Out.Ln;
END TestMath.

  8. Compilando e Executando os Testes

    Agora que temos um módulo de teste, vamos compilar e executar os testes para verificar se a função está correta.

    commands
    # Compile o módulo de teste
    gm2 my_project/src/TestMath.Mod my_project/src/Math.Mod -o my_project/test
    # Execute os testes
    ./my_project/test

  9. Interoperabilidade com C

    Modula-2 permite interoperabilidade com C, o que facilita o uso de bibliotecas existentes. Neste exemplo, criaremos um módulo C simples.

    C_Function.c
    #include <stdio.h>

int add(int a, int b) {
    return a + b;
}

void printHello() {
    printf("Hello from C!
    ");
}

  10. Chamando Código C a partir de Modula-2

    Vamos escrever um módulo Modula-2 que chama a função escrita em C. Isso envolve a declaração da função C no Modula-2 para que ela possa ser utilizada.

    MainWithC.Mod
    MODULE MainWithC;

IMPORT Out;

PROCEDURE add(a, b: INTEGER): INTEGER; EXTERN "C";

BEGIN
  Out.Int(add(5, 7), 0);
  Out.Ln;
END MainWithC.

Conclusão

Neste tutorial, você mergulhou no desenvolvimento prático com Modula-2, aprendendo desde a instalação das ferramentas necessárias até a estruturação de projetos modernos e a interoperabilidade com C. Embora Modula-2 não seja tão amplamente utilizado atualmente, suas características de programação modular e a capacidade de integração com outras linguagens ainda fazem dela uma opção viável para certos tipos de aplicações. Com a base adquirida aqui, você está pronto para explorar ainda mais o potencial dessa poderosa linguagem.

Hashtags

#Modula2 #DesenvolvimentoDeSoftware #ProgramacaoModular #Interoperabilidade #TestesUnitarios #ProgramacaoEmC