Introdução ao desenvolvimento com Nim para ferramentas de sistema

1. Por que Nim para ferramentas de sistema?

1.1. Compilação para C e desempenho nativo

Nim compila para C, o que significa que seus programas rodam sem a necessidade de uma máquina virtual ou runtime pesado. O binário gerado é nativo, pequeno e eficiente — características essenciais para ferramentas de sistema que precisam inicializar rapidamente e consumir poucos recursos. Além disso, a interoperabilidade com bibliotecas C é direta, permitindo chamar funções do sistema operacional sem camadas de abstração custosas.

1.2. Tipagem estática com inferência e sintaxe limpa

Diferente de linguagens como C ou Rust, Nim oferece tipagem estática com inferência, o que reduz a verbosidade do código sem sacrificar a segurança. A sintaxe é inspirada em Python, tornando a leitura e manutenção mais agradáveis. Para ferramentas de sistema, isso significa menos bugs de tipo e maior produtividade.

1.3. Gerenciamento de memória híbrido

Nim permite escolher entre garbage collection (GC) padrão, GC por ciclo de vida ou alocação manual completa. Para ferramentas de sistema que precisam de latência previsível, é possível desabilitar o GC e gerenciar memória manualmente com alloc/dealloc, similar ao que se faz em C.

2. Configuração do ambiente e primeiros passos

2.1. Instalação do compilador

O gerenciador de versões choosenim facilita a instalação e troca entre versões do Nim. No Linux/macOS:

curl -s https://nim-lang.org/choosenim/init.sh | sh

No Windows, baixe o instalador do site oficial. Após instalar, verifique:

nim --version

2.2. Estrutura de projeto com Nimble

Crie um novo projeto com:

nimble init mytool

Isso gera um arquivo mytool.nimble com metadados. Para dependências mínimas, edite o arquivo adicionando:

requires "nim >= 2.0.0"

2.3. Hello world de sistema: um comando CLI básico

Crie src/mytool.nim:

import os

proc main() =
  let args = commandLineParams()
  if args.len > 0:
    echo "Olá, ", args[0], "! Este é um comando de sistema."
  else:
    echo "Uso: mytool <nome>"

when isMainModule:
  main()

Compile e execute:

nim c -r src/mytool.nim
./src/mytool Mundo

3. Manipulação de arquivos e processos no sistema

3.1. Leitura/escrita de arquivos

Use os módulos os e streams para manipular arquivos:

import os, streams

proc readConfig(path: string): string =
  if fileExists(path):
    let f = newFileStream(path, fmRead)
    if f != nil:
      result = f.readAll()
      f.close()
  else:
    raise newException(IOError, "Arquivo não encontrado: " & path)

3.2. Execução de comandos externos

Com osproc, execute comandos e capture saída:

import osproc

let (output, exitCode) = execCmdEx("ls -la /tmp")
if exitCode == 0:
  echo "Saída:\n", output
else:
  echo "Erro: ", exitCode

3.3. Monitoramento de diretórios

No Linux, use inotify via módulo nativo ou polling:

import os, times

proc watchDir(path: string, interval: int) =
  var lastMod = getLastModificationTime(path)
  while true:
    sleep(interval)
    let current = getLastModificationTime(path)
    if current != lastMod:
      echo "Mudança detectada em: ", path
      lastMod = current

4. Interação com o sistema operacional

4.1. Chamadas de sistema de baixo nível

Use posix para chamadas Unix:

import posix

proc getPID(): int =
  result = int(getpid())

echo "PID do processo: ", getPID()

4.2. Gerenciamento de sinais

Capture SIGINT para finalização graciosa:

import posix

proc handleSignal(sig: cint) {.noconv.} =
  echo "\nSinal ", sig, " recebido. Finalizando..."
  quit(0)

setControlCHook(handleSignal)

echo "Pressione Ctrl+C para sair..."
while true:
  sleep(1000)

4.3. Variáveis de ambiente

Leia e manipule variáveis:

import os

let path = getEnv("PATH")
echo "PATH: ", path
setEnv("MYTOOL_DEBUG", "1")

5. Construção de ferramentas CLI robustas

5.1. Parsing de argumentos

Use parseopt para argumentos simples ou cligen para mais recursos:

import parseopt

proc main() =
  var optParser = initOptParser()
  for kind, key, val in optParser.getopt():
    case kind
    of cmdArgument:
      echo "Argumento: ", key
    of cmdLongOption, cmdShortOption:
      case key
      of "verbose", "v": echo "Modo verboso ativado"
      of "output", "o": echo "Saída: ", val
      else: discard
    of cmdEnd: break

5.2. Saída formatada no terminal

Use sequências ANSI para cores:

proc colorize(text: string, color: string): string =
  result = color & text & "\e[0m"

echo colorize("Erro!", "\e[31m")  # Vermelho
echo colorize("Sucesso!", "\e[32m")  # Verde

5.3. Tratamento de erros com Result

Use o tipo Result para evitar exceções:

import std/result

proc safeDivision(a, b: int): Result[int, string] =
  if b == 0:
    return err("Divisão por zero")
  else:
    return ok(a div b)

let res = safeDivision(10, 2)
if res.isOk:
  echo "Resultado: ", res.get()
else:
  echo "Erro: ", res.error()

6. Performance e alocação controlada

6.1. Alocação manual

Desabilite o GC e use alocação manual:

import alloc

proc main() =
  let size = 1024
  let buffer = alloc(size)
  if buffer != nil:
    copyMem(buffer, "dados", 5)
    dealloc(buffer)

6.2. Buffers pré-alocados

Para operações repetitivas, pré-aloque buffers:

var buffer = newString(4096)

proc readData(): string =
  # Simula leitura de dados
  result = "informação"

6.3. Perfilamento simples

Meça tempo de execução com times:

import times

let start = cpuTime()
# Código a ser medido
let elapsed = cpuTime() - start
echo "Tempo: ", elapsed, " segundos"

7. Exemplo prático: monitor de recursos do sistema

7.1. Coleta de métricas via /proc

No Linux, leia arquivos do /proc:

import os, streams

proc readCPU(): float =
  let f = newFileStream("/proc/stat", fmRead)
  if f != nil:
    let line = f.readLine()
    f.close()
    let parts = line.split()
    if parts.len > 4:
      let user = parseFloat(parts[1])
      let nice = parseFloat(parts[2])
      let system = parseFloat(parts[3])
      result = user + nice + system

proc readMemory(): int =
  let f = newFileStream("/proc/meminfo", fmRead)
  if f != nil:
    for line in f.lines():
      if line.startsWith("MemTotal:"):
        let parts = line.split()
        result = parseInt(parts[1])
        break
    f.close()

7.2. Loop de amostragem com saída JSON

import json, times

proc sample() =
  let cpu = readCPU()
  let mem = readMemory()
  let data = %*{"cpu": cpu, "memory": mem, "timestamp": epochTime()}
  echo data

while true:
  sample()
  sleep(2000)

7.3. Empacotamento como binário estático

Compile com suporte estático:

nim c -d:release --passL:-static src/monitor.nim

O binário resultante pode ser copiado para qualquer sistema Linux compatível.

8. Considerações finais e próximos passos

8.1. Ecossistema Nim para sistema

Bibliotecas recomendadas:
- nimline — leitura interativa de linha
- zerofunctional — programação funcional sem overhead
- jsony — parsing JSON rápido

8.2. Publicação no Nimble

Para distribuir sua ferramenta:

nimble publish

Isso disponibiliza o pacote no repositório oficial.

8.3. Leitura complementar

Explore projetos reais como nimble (gerenciador de pacotes) e nimgame para entender padrões de código.

Referências